iqm-pulse 12.5.0__tar.gz → 12.6.1__tar.gz

{iqm_pulse-12.5.0 → iqm_pulse-12.6.1}/CHANGELOG.rst

@@ -2,6 +2,20 @@
 Changelog
 =========
 
+Version 12.6.1 (2025-10-27)
+===========================
+
+- Bump version for 4.3.1 release. No functional changes.
+
+Version 12.6.0 (2025-10-23)
+===========================
+
+Features
+--------
+
+- ``cc_prx`` gate now supports ``prx`` gate implementations that consists of multiple drive IQ pulses,
+  e.g. ones that use the ``sx`` gate. As a result, the ``reset`` operation now also works with them.
+
 Version 12.5.0 (2025-10-09)
 ===========================
 

{iqm_pulse-12.5.0/src/iqm_pulse.egg-info → iqm_pulse-12.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.5.0
+Version: 12.6.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

{iqm_pulse-12.5.0 → iqm_pulse-12.6.1}/src/iqm/pulse/gates/conditional.py

@@ -18,10 +18,10 @@ import numpy as np
 from exa.common.data.parameter import CollectionType, Parameter
 from iqm.pulse.gate_implementation import CompositeGate
 from iqm.pulse.gates.measure import FEEDBACK_KEY
-from iqm.pulse.gates.prx import PRX_SinglePulse_GateImplementation
-from iqm.pulse.playlist.instructions import Block, ConditionalInstruction, Wait
+from iqm.pulse.playlist.instructions import Block, ConditionalInstruction, IQPulse, Wait
 from iqm.pulse.playlist.schedule import Schedule
 from iqm.pulse.timebox import TimeBox
+from iqm.pulse.utils import fuse_iq_pulses
 
 
 class CCPRX_Composite(CompositeGate):
@@ -30,6 +30,12 @@ class CCPRX_Composite(CompositeGate):
     Applies a PRX gate conditioned on a discriminated readout result obtained in the same segment (active feedback).
     Applies a PRX gate if the result is 1, and a Wait of equal duration if the result is 0.
     Uses the default implementation of PRX underneath, so no extra calibration is needed.
+
+    .. note::
+
+       Assumes that the PRX gate implementation used only consists of IQPulse instructions on the drive channel
+       of its locus qubit.
+
     """
 
     registered_gates = ("prx",)
@@ -70,30 +76,43 @@ class CCPRX_Composite(CompositeGate):
 
         """
         qubit = self.locus[0]
-        awg_name = self.builder.get_drive_channel(qubit)
+        drive_channel = self.builder.get_drive_channel(qubit)
+        prx_gate = self.build("prx", self.locus)
+
+        # NOTE assumes that the PRX gate only has IQPulse instructions on drive_channel
+        timebox: TimeBox = prx_gate(angle, phase)  # type: ignore[assignment]
+        if not timebox.atom:
+            raise RuntimeError("Received non-atomic PRX timebox.")
+        prx_instructions = timebox.atom[drive_channel]
+        iq_pulses = [inst for inst in prx_instructions if isinstance(inst, IQPulse)]
+        if len(iq_pulses) != len(prx_instructions):
+            raise RuntimeError(f"PRX drive channel has non-IQPulse instructions: {prx_instructions}")
+
+        if len(iq_pulses) > 1:
+            iq_pulse = fuse_iq_pulses(iq_pulses)
+        else:
+            iq_pulse = iq_pulses[0]
 
-        prx_gate: PRX_SinglePulse_GateImplementation = self.build("prx", self.locus)  # type: ignore[assignment]
-        # FIXME assumes PRX gates only use this one implementation as the default,
-        # with just a drive channel and a single IQPulse.
-        pulse = prx_gate(angle, phase).atom[prx_gate.channel][0]  # type: ignore[union-attr,index]
-        wait = Wait(pulse.duration)  # idling, can be replaced with a DD sequence later on
+        wait = Wait(iq_pulse.duration)  # idling, can be replaced with a DD sequence later on
 
         # TODO: use the actual inputted label when the HW supports many labels per drive channel
         default_label = f"{feedback_qubit}__{FEEDBACK_KEY}"
-        pulse_instruction = ConditionalInstruction(
-            duration=pulse.duration, condition=default_label, outcomes=(wait, pulse)
+        conditional_instruction = ConditionalInstruction(
+            duration=iq_pulse.duration,
+            condition=default_label,
+            outcomes=(wait, iq_pulse),
         )
         delays = self.calibration_data["control_delays"]
         if len(delays) == 0:
             raise ValueError(f"'control_delays' for '{self.name}' on {qubit} is empty (not calibrated).")
 
-        possible_sources = [c for c in self.builder.get_virtual_feedback_channels(qubit) if awg_name in c]
+        possible_sources = [c for c in self.builder.get_virtual_feedback_channels(qubit) if drive_channel in c]
         if len(delays) != len(possible_sources):
             raise ValueError(
                 f"Not the correct amount of calibration values for 'control_delays'. Need {len(possible_sources)}"
                 f"values, got {delays}."
             )
-        virtual_channel_name = self.builder.get_virtual_feedback_channel_for(awg_name, feedback_qubit)
+        virtual_channel_name = self.builder.get_virtual_feedback_channel_for(drive_channel, feedback_qubit)
         delay = delays[possible_sources.index(virtual_channel_name)]
         virtual_channel = self.builder.channels[virtual_channel_name]
         delay_samples = virtual_channel.duration_to_int_samples(
@@ -106,7 +125,7 @@ class CCPRX_Composite(CompositeGate):
         )
         delay_box.neighborhood_components = {0: {virtual_channel_name}}
         cond = TimeBox.atomic(
-            Schedule({virtual_channel_name: [Block(0)], prx_gate.channel: [pulse_instruction]}),
+            Schedule({virtual_channel_name: [Block(0)], drive_channel: [conditional_instruction]}),
             locus_components=[qubit],
             label=f"Conditional PRX for {qubit}",
         )

{iqm_pulse-12.5.0 → iqm_pulse-12.6.1}/src/iqm/pulse/playlist/waveforms.py

@@ -515,16 +515,13 @@ class ModulatedCosineRiseFall(Waveform):
 
 @dataclass(frozen=True)
 class CosineRise(Waveform):
-    r"""Cosine Rise waveform.
+    r"""Cosine rise waveform.
 
-    This waveform assumes that during its duration, the only thing happening is signal occurring to the required
+    This waveform assumes that during its duration, the only thing happening is signal rising to the required
     amplitude.
     The waveform is made for pairing with 'Constant' waveform to enable arbitrarily long pulses with smooth rise part.
     The rise time is equal to pulse duration.
 
-    Args:
-        rise_time: Dummy parameter, used only as due to a bug. FIXME it is not used, placed for resolving exa bug
-
     """
 
     def _sample(self, sample_coords: np.ndarray) -> np.ndarray:
@@ -533,7 +530,7 @@ class CosineRise(Waveform):
 
 @dataclass(frozen=True)
 class CosineFall(Waveform):
-    r"""Cosine Rise waveform.
+    r"""Cosine fall waveform.
 
     This waveform assumes that during its duration, the only thing occurring is signal falling to 0.
     The waveform is made for pairing with 'Constant' waveform to enable arbitrarily long pulses with smooth fall part.

iqm_pulse-12.6.1/src/iqm/pulse/utils.py

@@ -0,0 +1,195 @@
+#  ********************************************************************************
+#
+# Copyright 2024 IQM
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""Utility functions."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import replace
+from typing import get_args, get_origin
+
+import numpy as np
+
+from exa.common.data.parameter import CollectionType, DataType
+from iqm.pulse.playlist import IQPulse
+from iqm.pulse.playlist.waveforms import Samples
+
+
+def map_waveform_param_types(type_hint: type) -> tuple[DataType, CollectionType]:
+    """Map a python typehint into EXA Parameter's `(DataType, CollectionType)` tuple.
+
+    Args:
+        type: python typehint.
+
+    Returns:
+        A `(DataType, CollectionType)` tuple
+
+    Raises:
+        ValueError: for a non-supported type.
+
+    """
+    value_error = ValueError(f"Nonsupported datatype for a waveform parameter: {type_hint}")
+    if hasattr(type_hint, "__iter__") and type_hint is not str:
+        if type_hint == np.ndarray:
+            data_type = DataType.COMPLEX  # due to np.ndarray not being generic we assume complex numbers
+            collection_type = CollectionType.NDARRAY
+            return (data_type, collection_type)
+        if get_origin(type_hint) is list:
+            collection_type = CollectionType.LIST
+            type_hint = get_args(type_hint)[0]
+        else:
+            raise value_error
+    else:
+        collection_type = CollectionType.SCALAR
+
+    if type_hint is float:
+        data_type = DataType.FLOAT
+    elif type_hint is int:
+        data_type = DataType.INT
+    elif type_hint is str:
+        data_type = DataType.STRING
+    elif type_hint is complex:
+        data_type = DataType.COMPLEX
+    elif type_hint is bool:
+        data_type = DataType.BOOLEAN
+    else:
+        raise value_error
+    return (data_type, collection_type)
+
+
+def normalize_angle(angle: float) -> float:
+    """Normalize the given angle to (-pi, pi].
+
+    Args:
+        angle: angle to normalize (in radians)
+
+    Returns:
+        ``angle`` normalized to (-pi, pi]
+
+    """
+    half_turn = np.pi
+    full_turn = 2 * half_turn
+    return (angle - half_turn) % -full_turn + half_turn
+
+
+def phase_transformation(psi_1: float = 0.0, psi_2: float = 0.0) -> tuple[float, float]:
+    r"""Implement an arbitrary (RZ, PRX, RZ) gate sequence by modifying the parameters of the
+    IQ pulse implementing the PRX.
+
+    By commutation rules we have
+
+    .. math::
+       RZ(\psi_2) \: PRX(\theta, \phi) \: RZ(\psi_1) = PRX(\theta, \phi+\psi_2) \: RZ(\psi_1 + \psi_2).
+
+    Hence an arbitrary (RZ, PRX, RZ) gate sequence is equivalent to (RZ, PRX) with adjusted angles.
+
+    Use case: with resonant driving, the PRX gate can be implemented using an :class:`IQPulse` instance,
+    and the preceding RZ can be handled by decrementing the local oscillator phase beforehand (something
+    the IQPulse instruction can also do), which is equivalent to rotating the local computational frame
+    around the z axis in the opposite direction of the required quantum state rotation.
+
+    Args:
+        psi_1: RZ angle before the PRX (in rad)
+        psi_2: RZ angle after the PRX (in rad)
+
+    Returns:
+        change to the PRX phase angle (in rad),
+        phase increment for the IQ pulse that implements the remaining RZ (in rad)
+
+    """
+    return psi_2, -(psi_1 + psi_2)
+
+
+def modulate_iq(pulse: IQPulse) -> np.ndarray:
+    """Sampled baseband waveform of an IQ pulse.
+
+    Note that :attr:`IQPulse.phase_increment` has no effect on the sampled waveform.
+    The upconversion oscillator phase incrementation is a separate action performed by the AWG
+    that also affects future IQPulses, and thus cannot be represented by an array of waveform samples.
+    To replicate the effect of ``pulse`` on an AWG, one should first perform the increment and then
+    play the returned samples.
+
+    Args:
+        pulse: IQ pulse.
+
+    Returns:
+        The waveform of ``pulse`` as an array of complex-valued samples.
+
+    """
+    # TODO: Could be an IQPulse method
+    wave = pulse.wave_i.sample() * pulse.scale_i + 1j * pulse.wave_q.sample() * pulse.scale_q
+    # starting times of the samples, in units of inverse sample rate
+    wave_sampletimes = np.arange(len(wave))
+    wave *= np.exp(2j * np.pi * pulse.modulation_frequency * wave_sampletimes + 1j * pulse.phase)
+    return wave
+
+
+def fuse_iq_pulses(iq_pulses: Iterable[IQPulse]) -> IQPulse:
+    """Fuse multiple IQPulses into one by concatenating the sampled waveforms.
+
+    Works by flushing :attr:`IQPulse.phase_increment` s to the front, updating the :attr:`IQPulse.phase` s,
+    sampling the pulses, concatenating, normalizing the amplitudes, and putting the result
+    into a new IQPulse instruction with a ``phase_increment`` that is a sum of the individual ``phase_increment`` s.
+
+    Additionally, to conserve waveform memory on the AWGs, we normalize the waveform phase by setting
+    :attr:`IQPulse.phase` of the fused pulse to the flushed phase of the first pulse.
+
+    Args:
+        iq_pulses: IQPulse instructions to fuse.
+
+    Returns:
+        Fused IQPulse that behaves indentically to the sequence ``iq_pulses`` on an AWG.
+
+    """
+    # flush the phase increments to the start of the pulse sequence
+    phases = np.array([i.phase for i in iq_pulses])
+    phase_increments = np.array([i.phase_increment for i in iq_pulses])
+
+    # flushed_phases[k] == phases[k] - np.sum(phase_increments[k+1:])
+    flushed_phases = phases - np.cumsum(phase_increments[::-1])[::-1] + phase_increments
+
+    # Phase normalization of the samples to save waveform memory: There is an internal degree of freedom
+    # in the sampled IQPulse: IQPulse.phase can be represented in the global phase of the samples.
+    # Fix this d.o.f. by setting the phase of the fused IQ pulse to the phase of the first constituent IQ pulse.
+    fused_phase = flushed_phases[0]
+    flushed_phases -= fused_phase
+    flushed_iq_pulses = [
+        replace(instr, phase=phase, phase_increment=0.0) for instr, phase in zip(iq_pulses, flushed_phases)
+    ]
+    # sample and concatenate the IQ pulses
+    samples = np.hstack([modulate_iq(i) for i in flushed_iq_pulses])
+
+    # normalize the real and imaginary waveform components
+    def normalize(samples: np.ndarray) -> tuple[np.ndarray, float]:
+        """Normalize real-valued samples to [-1, 1]."""
+        scale = np.max(np.abs(samples))
+        # avoid division by zero
+        if scale > 0:
+            return samples / scale, scale
+        return samples, 1.0
+
+    samples.real, scale_i = normalize(samples.real)
+    samples.imag, scale_q = normalize(samples.imag)
+    return IQPulse(
+        duration=len(samples),
+        wave_i=Samples(samples.real),
+        wave_q=Samples(samples.imag),
+        scale_i=scale_i,
+        scale_q=scale_q,
+        phase=fused_phase,
+        phase_increment=np.sum(phase_increments),
+        modulation_frequency=0.0,  # modulate_iq takes care of this
+    )

{iqm_pulse-12.5.0 → iqm_pulse-12.6.1/src/iqm_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 12.5.0
+Version: 12.6.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

iqm_pulse-12.6.1/version.txt

@@ -0,0 +1 @@
+12.6.1

iqm_pulse-12.5.0/src/iqm/pulse/utils.py

@@ -1,109 +0,0 @@
-#  ********************************************************************************
-#
-# Copyright 2024 IQM
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-"""Utility functions."""
-
-from __future__ import annotations
-
-from typing import get_args, get_origin
-
-import numpy as np
-
-from exa.common.data.parameter import CollectionType, DataType
-
-
-def map_waveform_param_types(type_hint: type) -> tuple[DataType, CollectionType]:
-    """Map a python typehint into EXA Parameter's `(DataType, CollectionType)` tuple.
-
-    Args:
-        type: python typehint.
-
-    Returns:
-        A `(DataType, CollectionType)` tuple
-
-    Raises:
-        ValueError: for a non-supported type.
-
-    """
-    value_error = ValueError(f"Nonsupported datatype for a waveform parameter: {type_hint}")
-    if hasattr(type_hint, "__iter__") and type_hint is not str:
-        if type_hint == np.ndarray:
-            data_type = DataType.COMPLEX  # due to np.ndarray not being generic we assume complex numbers
-            collection_type = CollectionType.NDARRAY
-            return (data_type, collection_type)
-        if get_origin(type_hint) is list:
-            collection_type = CollectionType.LIST
-            type_hint = get_args(type_hint)[0]
-        else:
-            raise value_error
-    else:
-        collection_type = CollectionType.SCALAR
-
-    if type_hint is float:
-        data_type = DataType.FLOAT
-    elif type_hint is int:
-        data_type = DataType.INT
-    elif type_hint is str:
-        data_type = DataType.STRING
-    elif type_hint is complex:
-        data_type = DataType.COMPLEX
-    elif type_hint is bool:
-        data_type = DataType.BOOLEAN
-    else:
-        raise value_error
-    return (data_type, collection_type)
-
-
-def normalize_angle(angle: float) -> float:
-    """Normalize the given angle to (-pi, pi].
-
-    Args:
-        angle: angle to normalize (in radians)
-
-    Returns:
-        ``angle`` normalized to (-pi, pi]
-
-    """
-    half_turn = np.pi
-    full_turn = 2 * half_turn
-    return (angle - half_turn) % -full_turn + half_turn
-
-
-def phase_transformation(psi_1: float = 0.0, psi_2: float = 0.0) -> tuple[float, float]:
-    r"""Implement an arbitrary (RZ, PRX, RZ) gate sequence by modifying the parameters of the
-    IQ pulse implementing the PRX.
-
-    By commutation rules we have
-
-    .. math::
-       RZ(\psi_2) \: PRX(\theta, \phi) \: RZ(\psi_1) = PRX(\theta, \phi+\psi_2) \: RZ(\psi_1 + \psi_2).
-
-    Hence an arbitrary (RZ, PRX, RZ) gate sequence is equivalent to (RZ, PRX) with adjusted angles.
-
-    Use case: with resonant driving, the PRX gate can be implemented using an :class:`IQPulse` instance,
-    and the preceding RZ can be handled by decrementing the local oscillator phase beforehand (something
-    the IQPulse instruction can also do), which is equivalent to rotating the local computational frame
-    around the z axis in the opposite direction of the required quantum state rotation.
-
-    Args:
-        psi_1: RZ angle before the PRX (in rad)
-        psi_2: RZ angle after the PRX (in rad)
-
-    Returns:
-        change to the PRX phase angle (in rad),
-        phase increment for the IQ pulse that implements the remaining RZ (in rad)
-
-    """
-    return psi_2, -(psi_1 + psi_2)

iqm_pulse-12.5.0/version.txt

@@ -1 +0,0 @@
-12.5.0