iqm-pulse 10.2.0__tar.gz → 10.4.0__tar.gz

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/CHANGELOG.rst

@@ -2,6 +2,24 @@
 Changelog
 =========
 
+Version 10.4.0 (2025-08-12)
+===========================
+
+Features
+--------
+
+- Allow deprecating quantum operations and/or their implementations while still preserving them in the quantum operation
+  library (the names of deprecated canonical operations are still reserved).
+
+Version 10.3.0 (2025-08-11)
+===========================
+
+Feature
+-------
+
+- Added ``FluxPulse_SmoothConstant_SmoothConstant `` which automatically splits pulses into three parts: rise, Constant, and fall.
+- Changed Flux pulse argument ``parameter`` type to remove ignores all over the code.
+
 Version 10.2.0 (2025-08-08)
 ===========================
 

{iqm_pulse-10.2.0/src/iqm_pulse.egg-info → iqm_pulse-10.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 10.2.0
+Version: 10.4.0
 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-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/builder.py

@@ -45,7 +45,7 @@ from iqm.pulse.gate_implementation import (
     OpCalibrationDataTree,
 )
 from iqm.pulse.gates import _validate_implementation, get_implementation_class
-from iqm.pulse.gates.default_gates import _quantum_ops_library
+from iqm.pulse.gates.default_gates import _deprecated_implementations, _deprecated_ops, _quantum_ops_library
 from iqm.pulse.playlist.channel import ChannelProperties, ProbeChannelProperties
 from iqm.pulse.playlist.instructions import (
     AcquisitionMethod,
@@ -184,8 +184,12 @@ def validate_quantum_circuit(
 def build_quantum_ops(ops: dict[str, dict[str, Any]]) -> QuantumOpTable:
     """Builds the table of known quantum operations.
 
-    Hardcoded default native ops table is extended by the ones in ``ops``.
-    In case of name collisions, the content of ``ops`` takes priority over the defaults.
+    Hardcoded canonical ops table is extended by the ones in ``ops``.
+    In case of name collisions, the content of ``ops`` takes priority over the defaults,
+    with the following caveats:
+
+    * canonical implementation names cannot be redefined, and
+    * for canonical operations you can only change :attr:`implementations` and :attr:`defaults_for_locus`.
 
     Args:
         ops: Contents of the ``gate_definitions`` section defining
@@ -204,7 +208,23 @@ def build_quantum_ops(ops: dict[str, dict[str, Any]]) -> QuantumOpTable:
         ValueError: Operation attributes don't match defaults or are invalid.
 
     """
-    op_table = copy.deepcopy(_quantum_ops_library)
+    # build the table of native ops
+    op_table = {}
+    for op_name, op in _quantum_ops_library.items():
+        # filter out deprecated ops, unless requested by the user in ``ops``
+        if op_name in _deprecated_ops and op_name not in ops:
+            continue
+
+        new_op = copy.deepcopy(op)  # to prevent modifications to the hardcoded table
+        if (deprecated_impls := _deprecated_implementations.get(op_name)) is not None:
+            # filter out deprecated implementations
+            non_deprecated = {
+                impl_name: impl for impl_name, impl in op.implementations.items() if impl_name not in deprecated_impls
+            }
+            new_op = replace(op, implementations=non_deprecated)
+        op_table[op_name] = new_op
+
+    # add ops defined by the user
     for op_name, op_definition in ops.items():
         # prepare the implementations
         implementations: dict[str, type[GateImplementation]] = {}
@@ -236,9 +256,9 @@ def build_quantum_ops(ops: dict[str, dict[str, Any]]) -> QuantumOpTable:
                     f"appear in the implementations dict."
                 )
 
-        # prepare a new op, or modify the existing one
-        if (old_op := op_table.get(op_name)) is not None:
-            # known op: only some fields can be redefined, and they have been popped out already
+        if (old_op := _quantum_ops_library.get(op_name)) is not None:
+            # modify a canonical operation
+            # only some fields can be modified, and they have been popped out already from op_definition
             if op_definition:
                 # TODO this should be an error, but there are so many old experiment.yml files in use
                 # that still have the old syntax that being strict about this would be disruptive.
@@ -247,15 +267,17 @@ def build_quantum_ops(ops: dict[str, dict[str, Any]]) -> QuantumOpTable:
                     f"'{op_name}' is a canonical operation, which means the fields {set(op_definition)} "
                     "provided by the user may not be changed."
                 )
-            op_table[op_name] = replace(old_op, implementations=implementations, defaults_for_locus=defaults_for_locus)
+
+            op = replace(old_op, implementations=implementations, defaults_for_locus=defaults_for_locus)
         else:
-            # new op
-            op_table[op_name] = QuantumOp(
+            # entirely new quantum operation defined by the user
+            op = QuantumOp(
                 name=op_name,
                 implementations=implementations,
                 defaults_for_locus=defaults_for_locus,
                 **op_definition,
             )
+        op_table[op_name] = op
 
     return op_table
 

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/gates/__init__.py

@@ -42,10 +42,11 @@ from iqm.pulse.gates.cz import (
     CZ_Slepian_ACStarkCRF,
     CZ_Slepian_CRF,
     CZ_TruncatedGaussianSmoothedSquare,
+    FluxPulse_SmoothConstant_SmoothConstant,
     FluxPulseGate_CRF_CRF,
     FluxPulseGate_TGSS_CRF,
 )
-from iqm.pulse.gates.default_gates import _default_implementations, _quantum_ops_library
+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
@@ -98,6 +99,7 @@ _exposed_implementations: dict[str, type[GateImplementation]] = {
         CZ_Slepian,
         CZ_Slepian_CRF,
         CZ_CRF,
+        FluxPulse_SmoothConstant_SmoothConstant,
         CZ_TruncatedGaussianSmoothedSquare,
         FluxPulseGate_TGSS_CRF,
         FluxPulseGate_CRF_CRF,
@@ -155,7 +157,7 @@ def _validate_implementation(
         ValueError: A canonical implementation name is being redefined.
 
     """
-    default_implementations = _default_implementations.get(op_name, {})
+    default_implementations = _implementation_library.get(op_name, {})
 
     # check if the implementation name is canonical for this op
     if (impl_class := default_implementations.get(impl_name)) is not None:

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/gates/cz.py

@@ -22,6 +22,7 @@ It can be represented by the unitary matrix
 from __future__ import annotations
 
 from dataclasses import replace
+import logging
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -32,14 +33,16 @@ from iqm.pulse.gate_implementation import GateImplementation, Locus, OILCalibrat
 from iqm.pulse.playlist.instructions import Block, FluxPulse, Instruction, IQPulse, VirtualRZ
 from iqm.pulse.playlist.schedule import Schedule
 from iqm.pulse.playlist.waveforms import (
+    Constant,
+    CosineFallFlex,
     CosineRiseFall,
+    CosineRiseFlex,
     GaussianSmoothedSquare,
     ModulatedCosineRiseFall,
     Slepian,
     TruncatedGaussianSmoothedSquare,
     Waveform,
 )
-from iqm.pulse.timebox import TimeBox
 from iqm.pulse.utils import phase_transformation
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -79,9 +82,9 @@ class FluxPulseGate(GateImplementation):
     """Flux pulse Waveform to be played in the coupler flux AWG."""
     qubit_wave: type[Waveform] | None
     """Flux pulse Waveform to be played in the qubit flux AWG."""
-    root_parameters: dict[str, Parameter | Setting] = {
+    root_parameters: dict[str, Parameter | Setting | dict] = {
         "duration": Parameter("", "Gate duration", "s"),
-        "rz": {  # type: ignore[dict-item]
+        "rz": {
             "*": Parameter("", "Z rotation angle", "rad"),  # wildcard parameter
         },
     }
@@ -261,9 +264,9 @@ class CouplerFluxPulseQubitACStarkPulseGate(GateImplementation):
     qubit_drive_wave: type[Waveform] | None
     """Qubit drive pulse waveform to be played in the qubit drive AWG."""
 
-    root_parameters: dict[str, Parameter | Setting] = {
+    root_parameters: dict[str, Parameter | Setting | dict] = {
         "duration": Parameter("", "Gate duration", "s"),
-        "rz": {  # type: ignore[dict-item]
+        "rz": {
             "*": Parameter("", "Z rotation angle", "rad"),
         },
     }
@@ -426,3 +429,303 @@ class CZ_CRF_ACStarkCRF(
     CZ gate implemented using a cosine rise fall flux pulse for the coupler and a modulated
     cosine rise fall (CRF) AC Stark pulse on one qubit.
     """
+
+
+def round_to_granularity(value: float, granularity: float, precision: float = 1e-15) -> float:
+    """Round a value to the nearest multiple of granularity.
+    If the value is within a given precision of a multiple, round to that multiple.
+    Otherwise, round down to the nearest lower multiple.
+
+    Args:
+        value:
+        granularity: granularity
+        precision: rounding precision.
+
+    Returns:
+        value rounded to a granularity.
+
+    """
+    return np.floor(value / granularity + precision) * granularity
+
+
+def split_flat_top_part_into_granular_parts(
+    duration: float, full_width: float, rise_time: float, granularity: float, precision: float = 1e-10
+) -> tuple[float, float, float, float]:
+    """To save waveform memory, a (long) flat-top pulse, which is defined by its duration, full_width and rise_time,
+    is divided into three consecutive parts (rise, flat, and fall),
+    all of which conform to the granularity of the device.
+
+    Args:
+        duration: pulse duration in seconds.
+        full_width: full width of the pulse.
+        rise_time: rise time of the pulse.
+        granularity: minimum allowed pulse duration.
+        precision: precision of rounding to granularity,
+
+
+    Returns:
+        A tuple containing:
+        - flat part duration
+        - rise (or fall) part duration
+        - rise time
+        - flat part's non-granular leftover, which is transferred to the rise and fall parts
+
+    Raises:
+        ValueError: Error is raised if duration is not a multiple of granularity.
+        ValueError: Error is raised if pulse parameters do not obey duration >= full_width >= 2*rise_time.
+
+    """
+    # Check if the number of samples is within 0.005 samples of an integer number, considered safe.
+    if not round(duration / granularity, ndigits=2).is_integer():
+        raise ValueError("Duration must be a multiple of granularity.")
+
+    if (duration >= full_width) & (full_width >= 2 * rise_time):
+        plateau_width = full_width - 2 * rise_time
+
+        plateau_width_granular = round_to_granularity(plateau_width, granularity)
+        rise_duration = (duration - plateau_width_granular) / 2
+
+        if np.abs(rise_duration - np.round(rise_duration / granularity) * granularity) > precision:
+            plateau_width_granular -= granularity
+            rise_duration = (duration - plateau_width_granular) / 2
+
+        flat_part = duration - 2 * rise_duration
+        plateau_leftover = (full_width - 2 * rise_time - flat_part) / 2
+
+        return plateau_width_granular, rise_duration, rise_time, plateau_leftover
+    else:
+        raise ValueError(
+            f"Current pulse parameters (duration {duration}, full_width {full_width}, rise_time {rise_time}) "
+            f"are impossible, please use duration >= full_width >= 2*rise_time."
+        )
+
+
+class FluxPulseGate_SmoothConstant(FluxPulseGate):
+    """Flux pulse gate implementation realized as a 3-part pulse sequence,
+    consisting of |cosine rise|Constant|cosine fall|. Otherwise, works similar to FluxPulseGate.
+
+    Args:
+        flux_pulses: mapping from flux channel name to its flux pulse
+        rz: mapping from drive channel name to the virtual z rotation angle, in radians, that should be performed on it
+
+    """
+
+    coupler_wave: Constant | None
+    """Flux pulse Waveform to be played in the coupler flux AWG. Can be only Constant or None"""
+    qubit_wave: Constant | None
+    """Flux pulse Waveform to be played in the qubit flux AWG. Can be only Constant or None"""
+    rise_wave: type[Waveform] = CosineRiseFlex
+    """Waveform, rise part of the 3-pulse sequence to be played with qubit and coupler gates."""
+    fall_wave: type[Waveform] = CosineFallFlex
+    """Waveform, fall part of the 3-pulse sequence to be played with qubit and coupler gates."""
+
+    root_parameters: dict[str, Parameter | Setting | dict] = {
+        "duration": Parameter("", "Gate duration", "s"),
+        "qubit": {
+            "rise_time": Parameter("", "Qubit pulse rise time", "s"),
+            "full_width": Parameter("", "Qubit pulse full width", "s"),
+            "amplitude": Parameter("", "Qubit pulse amplitude", ""),
+        },
+        "coupler": {
+            "rise_time": Parameter("", "Coupler pulse rise time", "s"),
+            "full_width": Parameter("", "Coupler pulse full width", "s"),
+            "amplitude": Parameter("", "Coupler pulse amplitude", ""),
+        },
+        "rz": {
+            "*": Parameter("", "Z rotation angle", "rad"),
+        },
+    }
+
+    def __init__(
+        self,
+        parent: QuantumOp,
+        name: str,
+        locus: Locus,
+        calibration_data: OILCalibrationData,
+        builder: ScheduleBuilder,
+    ) -> None:
+        GateImplementation.__init__(self, parent, name, locus, calibration_data, builder)
+        duration = calibration_data["duration"]
+
+        flux_pulses = {}
+        rise_pulses = {}
+        fall_pulses = {}
+
+        def build_flux_pulse(waveform_class: type[Waveform], component_name: str, cal_node_name: str) -> None:
+            """Uses a part of the gate calibration data to prepare a flux pulse for the given component."""
+            flux_channel = builder.get_flux_channel(component_name)
+
+            granularity = builder.channels[flux_channel].duration_to_seconds(
+                builder.channels[flux_channel].instruction_duration_min
+            )
+
+            data = calibration_data[cal_node_name]
+            calibration_data_constant = data.copy()
+            calibration_data_rise = data.copy()
+
+            plateau_width_granular, rise_duration, rise_time, plateau_leftover = (
+                split_flat_top_part_into_granular_parts(duration, data["full_width"], data["rise_time"], granularity)
+            )
+            calibration_data_rise["rise_time"] = rise_time
+            calibration_data_constant["duration"] = plateau_width_granular
+            calibration_data_rise["duration"] = rise_duration
+            calibration_data_rise["full_width"] = plateau_leftover + rise_time
+
+            if plateau_width_granular > 0:
+                params_for_flux_pulses = self.convert_calibration_data(
+                    calibration_data=calibration_data_constant,
+                    params=self.parameters[cal_node_name],  # type: ignore[arg-type]
+                    channel_props=builder.channels[flux_channel],
+                    duration=plateau_width_granular,
+                )
+            else:
+                params_for_flux_pulses = {"n_samples": 0, "amplitude": calibration_data_constant["amplitude"]}
+
+            params_for_risefall = self.convert_calibration_data(
+                calibration_data=calibration_data_rise,
+                params=self.parameters[cal_node_name],  # type: ignore[arg-type]
+                channel_props=builder.channels[flux_channel],
+                duration=rise_duration,
+            )
+
+            params_for_flux_pulses["n_samples"] = (
+                builder.channels[flux_channel].duration_to_int_samples(plateau_width_granular)
+                if plateau_width_granular > 0
+                else 0
+            )
+
+            params_for_risefall["n_samples"] = (
+                builder.channels[flux_channel].duration_to_int_samples(rise_duration) if rise_duration > 0 else 0
+            )
+
+            amplitude = params_for_flux_pulses.pop("amplitude")
+            params_for_risefall.pop("amplitude")
+
+            flux_pulses[flux_channel] = (
+                FluxPulse(
+                    duration=params_for_flux_pulses["n_samples"],
+                    wave=waveform_class(n_samples=params_for_flux_pulses["n_samples"]),
+                    scale=amplitude,
+                )
+                if params_for_flux_pulses["n_samples"] > 0
+                else None
+            )
+
+            if params_for_risefall["n_samples"] > 0:
+                rise_pulses[flux_channel] = FluxPulse(
+                    duration=params_for_risefall["n_samples"],
+                    wave=self.rise_wave(**params_for_risefall),
+                    scale=amplitude,
+                )
+                fall_pulses[flux_channel] = FluxPulse(
+                    duration=params_for_risefall["n_samples"],
+                    wave=self.fall_wave(**params_for_risefall),
+                    scale=amplitude,
+                )
+            else:
+                rise_pulses[flux_channel] = None  # type: ignore[assignment]
+                fall_pulses[flux_channel] = None  # type: ignore[assignment]
+
+        if self.coupler_wave is not None:
+            build_flux_pulse(self.coupler_wave, builder.chip_topology.get_coupler_for(*locus), "coupler")
+
+        if self.qubit_wave is not None:
+            # the pulsed qubit is always the first one of the locus
+            build_flux_pulse(self.qubit_wave, locus[0], "qubit")
+
+        rz = calibration_data["rz"]
+        for c in locus:
+            if c not in rz:
+                raise ValueError(
+                    f"{parent.name}.{name}: {locus}: Calibration is missing an RZ angle for locus component {c}."
+                )
+        rz_locus = {builder.get_drive_channel(c): angle for c, angle in rz.items() if c in locus}
+        rz_not_locus = tuple((builder.get_drive_channel(c), angle) for c, angle in rz.items() if c not in locus)
+
+        schedule: dict[str, list[Instruction]] = {
+            channel: [
+                VirtualRZ(
+                    duration=builder.channels[channel].duration_to_int_samples(duration),
+                    phase_increment=-angle,
+                )
+            ]
+            for channel, angle in rz_locus.items()
+        }
+        vzs_inserted = False  # insert the long-distance Vzs to the first flux pulse (whatever that is)
+        for channel, flux_pulse in flux_pulses.items():
+            if rz_not_locus and not vzs_inserted and flux_pulse:
+                schedule[channel] = [replace(flux_pulse, rzs=rz_not_locus)]
+                vzs_inserted = True
+            elif duration > 0:
+                schedule[channel] = [
+                    v for v in [rise_pulses[channel], flux_pulse, fall_pulses[channel]] if v is not None
+                ]
+            else:
+                schedule[channel] = []
+        affected_components = set(locus)
+        affected_components.add(builder.chip_topology.get_coupler_for(*locus))
+        self._affected_components = affected_components
+        self._schedule = Schedule(schedule if duration > 0 else {c: [Block(0)] for c in schedule}, duration=duration)
+
+    def __init_subclass__(
+        cls,
+        /,
+        coupler_wave: type[Waveform] | None = None,
+        qubit_wave: type[Waveform] | None = None,
+        rise_wave: type[Waveform] = CosineRiseFlex,
+        fall_wave: type[Waveform] = CosineFallFlex,
+    ):
+        if coupler_wave is None and qubit_wave is None and hasattr(cls, "coupler_wave") and hasattr(cls, "qubit_wave"):
+            return
+        if coupler_wave and (coupler_wave != Constant):
+            logging.getLogger(__name__).warning(
+                "Forcing coupler wave to be Constant",
+            )
+            coupler_wave = Constant
+        if qubit_wave and (qubit_wave != Constant):
+            logging.getLogger(__name__).warning(
+                "Forcing qubit wave to be Constant",
+            )
+            qubit_wave = Constant
+
+        cls.coupler_wave = coupler_wave
+        cls.qubit_wave = qubit_wave
+        cls.symmetric = cls.qubit_wave is None
+        cls.fall_wave = fall_wave
+        cls.rise_wave = rise_wave
+
+        root_parameters = {k: v for k, v in cls.root_parameters.items() if k not in cls.excluded_parameters}
+        parameters = {}
+        if coupler_wave is not None:
+            parameters["coupler"] = (
+                get_waveform_parameters(rise_wave, label_prefix="Coupler flux pulse ")
+                | get_waveform_parameters(fall_wave, label_prefix="Coupler flux pulse ")
+                | get_waveform_parameters(coupler_wave, label_prefix="Coupler flux pulse ")
+            )
+            parameters["coupler"]["amplitude"] = Parameter("", "Coupler flux pulse amplitude", "")
+            parameters["coupler"]["rise_time"] = Parameter("", "Coupler flux pulse rise time", "s")
+            parameters["coupler"]["full_width"] = Parameter("", "Coupler flux pulse full width", "s")
+
+        if qubit_wave is not None:
+            parameters["qubit"] = (
+                get_waveform_parameters(rise_wave, label_prefix="Qubit flux pulse ")
+                | get_waveform_parameters(fall_wave, label_prefix="Qubit flux pulse ")
+                | get_waveform_parameters(qubit_wave, label_prefix="Qubit flux pulse ")
+            )
+            parameters["qubit"]["amplitude"] = Parameter("", "Qubit flux pulse amplitude", "")
+            parameters["qubit"]["rise_time"] = Parameter("", "Qubit flux pulse rise time", "s")
+            parameters["qubit"]["full_width"] = Parameter("", "Qubit flux pulse full width", "s")
+
+        cls.parameters = root_parameters | {k: v for k, v in parameters.items() if k not in cls.excluded_parameters}
+
+
+class FluxPulse_SmoothConstant_qubit(FluxPulseGate_SmoothConstant, qubit_wave=Constant):
+    """Constant flux pulse on qubit with smooth rise/fall"""
+
+
+class FluxPulse_SmoothConstant_coupler(FluxPulseGate_SmoothConstant, coupler_wave=Constant):
+    """Constant flux pulse on coupler with smooth rise/fall."""
+
+
+class FluxPulse_SmoothConstant_SmoothConstant(FluxPulseGate_SmoothConstant, coupler_wave=Constant, qubit_wave=Constant):
+    """Constant flux pulse on both qubit and coupler with smooth rise/fall."""

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/gates/default_gates.py

@@ -15,7 +15,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Final
 
 import numpy as np
 
@@ -63,7 +63,7 @@ if TYPE_CHECKING:
     from iqm.pulse.gate_implementation import GateImplementation
 
 
-_default_implementations: dict[str, dict[str, type[GateImplementation]]] = {
+_implementation_library: dict[str, dict[str, type[GateImplementation]]] = {
     "barrier": {"": Barrier},
     "delay": {"wait": Delay},
     "measure": {
@@ -105,9 +105,11 @@ _default_implementations: dict[str, dict[str, type[GateImplementation]]] = {
     "reset_wait": {"reset_wait": Reset_Wait},
     "flux_multiplexer": {"sample_linear": FluxMultiplexer_SampleLinear},
 }
-"""Canonical implementation names for the canonical quantum operations.
-A collection of mappings between default implementation names and their GateImplementation classes,
-for different gates."""
+"""For each canonical quantum operation name, maps its canonical implementation implementation names
+to their GateImplementation classes.
+
+Canonical names are reserved, and the users cannot redefine them.
+"""
 
 _quantum_ops_library = {
     op.name: op
@@ -115,101 +117,113 @@ _quantum_ops_library = {
         QuantumOp(
             "barrier",
             0,
-            implementations=_default_implementations["barrier"],  # type: ignore[arg-type]
+            implementations=_implementation_library["barrier"],
             symmetric=True,
         ),
         QuantumOp(
             "delay",
             0,
             ("duration",),
-            implementations=_default_implementations["delay"],  # type: ignore[arg-type]
+            implementations=_implementation_library["delay"],
             symmetric=True,
         ),
         QuantumOp(
             "measure",
             0,
             ("key",),
-            implementations=_default_implementations["measure"],  # type: ignore[arg-type]
+            implementations=_implementation_library["measure"],
             factorizable=True,
         ),
         QuantumOp(
             "prx",
             1,
             ("angle", "phase"),
-            implementations=_default_implementations["prx"],  # type: ignore[arg-type]
+            implementations=_implementation_library["prx"],
             unitary=get_unitary_prx,
         ),
         QuantumOp(
             "prx_12",
             1,
             ("angle", "phase"),
-            implementations=_default_implementations["prx_12"],  # type: ignore[arg-type]
+            implementations=_implementation_library["prx_12"],
         ),
         QuantumOp(
             "u",
             1,
             ("theta", "phi", "lam"),
-            implementations=_default_implementations["u"],  # type: ignore[arg-type]
+            implementations=_implementation_library["u"],
             unitary=get_unitary_u,
         ),
         QuantumOp(
             "sx",
             1,
-            implementations=_default_implementations["sx"],  # type: ignore[arg-type]
+            implementations=_implementation_library["sx"],
             unitary=lambda: get_unitary_prx(np.pi / 2, 0),
         ),
         QuantumOp(
             "rz",
             1,
             ("angle",),
-            implementations=_default_implementations["rz"],  # type: ignore[arg-type]
+            implementations=_implementation_library["rz"],
             unitary=get_unitary_rz,
         ),
         QuantumOp(
             "rz_physical",
             1,
-            implementations=_default_implementations["rz_physical"],  # type: ignore[arg-type]
+            implementations=_implementation_library["rz_physical"],
         ),
         QuantumOp(
             "cz",
             2,
             (),
-            implementations=_default_implementations["cz"],  # type: ignore[arg-type]
+            implementations=_implementation_library["cz"],
             symmetric=True,
             unitary=lambda: np.diag([1.0, 1.0, 1.0, -1.0]),
         ),
         QuantumOp(
             "move",
             2,
-            implementations=_default_implementations["move"],  # type: ignore[arg-type]
+            implementations=_implementation_library["move"],
         ),
         QuantumOp(
             "cc_prx",
             1,
             ("angle", "phase", "feedback_qubit", "feedback_key"),
-            implementations=_default_implementations["cc_prx"],  # type: ignore[arg-type]
+            implementations=_implementation_library["cc_prx"],
         ),
         QuantumOp(
             "reset",
             0,
-            implementations=_default_implementations["reset"],  # type: ignore[arg-type]
+            implementations=_implementation_library["reset"],
             symmetric=True,
             factorizable=True,
         ),
         QuantumOp(
             "reset_wait",
             0,
-            implementations=_default_implementations["reset_wait"],  # type: ignore[arg-type]
+            implementations=_implementation_library["reset_wait"],
             symmetric=True,
             factorizable=True,
         ),
         QuantumOp(
             "flux_multiplexer",
             0,
-            implementations=_default_implementations["flux_multiplexer"],  # type: ignore[arg-type]
+            implementations=_implementation_library["flux_multiplexer"],
         ),
     ]
 }
-"""Library of the current canonical quantum operations provided by iqm-pulse."""
-# NOTE If a canonical operation is removed in the future, consider adding a second dict for former
-# canonical operations so that we retain information about them.
+"""Canonical quantum operations provided by iqm-pulse.
+
+Their names are reserved, and the users cannot redefine them.
+"""
+
+_deprecated_ops: Final[set[str]] = set()
+"""Names of canonical quantum operations that are deprecated.
+
+They are not included by default in ScheduleBuilder unless the user specifically requests them."""
+_deprecated_implementations: Final[dict[str, set[str]]] = {}
+"""For each canonical quantum operation name, canonical implementation names that are deprecated.
+
+They are not included by default in ScheduleBuilder unless the user specifically requests them."""
+# TODO: deprecate gaussian_smoothed_square and everything with the tgss waveform as that is considered inferior to crf.
+# TODO: deprecate PRX_drag_gaussian

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/gates/move.py

@@ -102,9 +102,9 @@ class MOVE_CustomWaveforms(FluxPulseGate):
     The phases are calculated and applied on the qubits using :func:`.apply_move_gate_phase_corrections`.
     """
 
-    root_parameters: dict[str, Parameter | Setting] = {
+    root_parameters: dict[str, Parameter | Setting | dict] = {
         "duration": Parameter("", "Gate duration", "s"),
-        "rz": {  # type: ignore[dict-item]
+        "rz": {
             "*": Parameter("", "Z rotation angle", "rad"),  # wildcard parameter
         },
         "detuning": Parameter("", "Qubit - resonator detuning", "Hz"),

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0}/src/iqm/pulse/playlist/waveforms.py

@@ -498,3 +498,95 @@ class CosineFall(Waveform):
 
     def _sample(self, sample_coords: np.ndarray) -> np.ndarray:
         return 0.5 - 0.5 * np.sin(np.pi * sample_coords)
+
+
+@dataclass(frozen=True)
+class CosineRiseFlex(Waveform):
+    r"""Cosine Rise waveform with an extra duration buffer.
+
+    The waveform is a piecewise function: |buffer|cosine rise|flat plateau|, where:
+    - buffer is a 'leftover' constant signal with amplitude = 0, with duration of duration - full_width
+    - cosine rise is a cosine rise pulse with a duration of rise_time
+    - flat plateau is a constant signal with amplitude = 1, with duration of full_width - rise_time
+
+    Args:
+        rise_time: rise time of the waveform
+        full_width: combined duration of the cosine rise time and the flat plateau
+
+    Raises:
+        ValueError: Error is raised if full_width or rise_time is more than duration
+
+    """
+
+    rise_time: float
+    full_width: float
+
+    def _sample(self, sample_coords: np.ndarray) -> np.ndarray:
+        flat_part_duration = np.abs(self.full_width) - np.abs(self.rise_time)
+        rise_time_duration = np.abs(self.rise_time)
+        dead_wait_time = 1 - np.abs(self.full_width)
+
+        if dead_wait_time >= 0:
+            return np.piecewise(
+                sample_coords,
+                [
+                    sample_coords <= 0.5 - flat_part_duration - rise_time_duration,
+                    sample_coords > 0.5 - flat_part_duration - rise_time_duration,
+                    sample_coords >= 0.5 - flat_part_duration,  # flat carry-over from the Constant
+                ],
+                [
+                    0,
+                    lambda oc: 0.5 - 0.5 * np.cos(np.pi / rise_time_duration * (oc - dead_wait_time + 0.5)),
+                    1,
+                ],
+            )
+        elif (flat_part_duration + dead_wait_time > 0) and (1 - rise_time_duration >= 0):
+            raise ValueError("Full width is more than duration")
+        else:
+            raise ValueError("Rise time is more than duration")
+
+
+@dataclass(frozen=True)
+class CosineFallFlex(Waveform):
+    r"""Cosine fall waveform with an extra duration buffer.
+
+    The waveform is a piecewise function: |flat plateau|cosine fall|buffer|, where:
+    - buffer is a 'leftover' constant signal with amplitude = 0, generally with duration of duration - full_width
+    - cosine fall is a cosine fall pulse with a duration of rise_time
+    - flat plateau is a constant signal with amplitude = 1, generally with duration of full_width - rise_time
+
+    Args:
+        rise_time: rise time of the waveform
+        full_width: combined duration of the cosine fall time and the flat plateau
+
+    Raises:
+        ValueError: Error is raised if full_width or rise_time is more than duration
+
+    """
+
+    rise_time: float
+    full_width: float
+
+    def _sample(self, sample_coords: np.ndarray) -> np.ndarray:
+        flat_part_duration = max(np.abs(self.full_width) - np.abs(self.rise_time), 0)
+        rise_time_duration = np.abs(self.rise_time)
+        dead_wait_time = 1 - flat_part_duration - rise_time_duration
+
+        if dead_wait_time >= 0:
+            return np.piecewise(
+                sample_coords,
+                [
+                    sample_coords <= -0.5 + flat_part_duration,  # flat corry-over from the Constant
+                    sample_coords > -0.5 + flat_part_duration,
+                    sample_coords >= -0.5 + flat_part_duration + rise_time_duration,
+                ],
+                [
+                    1,
+                    lambda oc: 0.5 + 0.5 * np.cos(np.pi / rise_time_duration * (oc - flat_part_duration + 0.5)),
+                    0,
+                ],
+            )
+        elif (flat_part_duration + dead_wait_time > 0) and (1 - rise_time_duration >= 0):
+            raise ValueError("Full width is more than duration")
+        else:
+            raise ValueError("Rise time is more than duration")

{iqm_pulse-10.2.0 → iqm_pulse-10.4.0/src/iqm_pulse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-pulse
-Version: 10.2.0
+Version: 10.4.0
 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-10.4.0/version.txt

@@ -0,0 +1 @@
+10.4.0

iqm_pulse-10.2.0/version.txt

@@ -1 +0,0 @@
-10.2.0