qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/calibration/pulse_gate.py

@@ -1,100 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Instruction schedule map reference pass."""
-
-from typing import List, Union
-
-from qiskit.circuit import Instruction as CircuitInst
-from qiskit.pulse import Schedule, ScheduleBlock
-from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
-from qiskit.transpiler.target import Target
-from qiskit.transpiler.exceptions import TranspilerError
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-from .base_builder import CalibrationBuilder
-
-
-class PulseGates(CalibrationBuilder):
-    """Pulse gate adding pass.
-
-    This pass adds gate calibrations from the supplied ``InstructionScheduleMap``
-    to a quantum circuit.
-
-    This pass checks each DAG circuit node and acquires a corresponding schedule from
-    the instruction schedule map object that may be provided by the target backend.
-    Because this map is a mutable object, the end-user can provide a configured backend to
-    execute the circuit with customized gate implementations.
-
-    This mapping object returns a schedule with "publisher" metadata which is an integer Enum
-    value representing who created the gate schedule.
-    If the gate schedule is provided by end-users, this pass attaches the schedule to
-    the DAG circuit as a calibration.
-
-    This pass allows users to easily override quantum circuit with custom gate definitions
-    without directly dealing with those schedules.
-
-    References
-        * [1] OpenQASM 3: A broader and deeper quantum assembly language
-          https://arxiv.org/abs/2104.14722
-    """
-
-    @deprecate_pulse_dependency
-    def __init__(
-        self,
-        inst_map: InstructionScheduleMap = None,
-        target: Target = None,
-    ):
-        """Create new pass.
-
-        Args:
-            inst_map: Instruction schedule map that user may override.
-            target: The :class:`~.Target` representing the target backend, if both
-                ``inst_map`` and ``target`` are specified then it updates instructions
-                in the ``target`` with ``inst_map``.
-        """
-        super().__init__()
-
-        if inst_map is None and target is None:
-            raise TranspilerError("inst_map and target cannot be None simulataneously.")
-
-        if target is None:
-            target = Target()
-            target.update_from_instruction_schedule_map(inst_map)
-        self.target = target
-
-    def supported(self, node_op: CircuitInst, qubits: List) -> bool:
-        """Determine if a given node supports the calibration.
-
-        Args:
-            node_op: Target instruction object.
-            qubits: Integer qubit indices to check.
-
-        Returns:
-            Return ``True`` is calibration can be provided.
-        """
-        return self.target._has_calibration(node_op.name, tuple(qubits))
-
-    def get_calibration(self, node_op: CircuitInst, qubits: List) -> Union[Schedule, ScheduleBlock]:
-        """Gets the calibrated schedule for the given instruction and qubits.
-
-        Args:
-            node_op: Target instruction object.
-            qubits: Integer qubit indices to check.
-
-        Returns:
-            Return Schedule of target gate instruction.
-
-        Raises:
-            TranspilerError: When node is parameterized and calibration is raw schedule object.
-        """
-        return self.target._get_calibration(node_op.name, tuple(qubits), *node_op.params)

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -1,164 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Add single-pulse RX calibrations that are bootstrapped from the SX calibration."""
-
-from typing import Union
-from functools import lru_cache
-import numpy as np
-
-from qiskit.circuit import Instruction
-from qiskit.circuit.library.standard_gates import RXGate
-from qiskit.exceptions import QiskitError
-from qiskit.pulse import Schedule, ScheduleBlock, builder, ScalableSymbolicPulse
-from qiskit.pulse.channels import Channel
-from qiskit.pulse.library.symbolic_pulses import Drag
-from qiskit.transpiler.passes.calibration.base_builder import CalibrationBuilder
-from qiskit.transpiler.target import Target
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-
-class RXCalibrationBuilder(CalibrationBuilder):
-    """Add single-pulse RX calibrations that are bootstrapped from the SX calibration.
-
-    .. note::
-
-        Requirement: NormalizeRXAngles pass (one of the optimization passes).
-
-    It is recommended to place this pass in the post-optimization stage of a passmanager.
-    A simple demo:
-
-    .. code-block:: python
-
-       from qiskit.providers.fake_provider import GenericBackendV2
-       from qiskit.transpiler import PassManager, PassManagerConfig
-       from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
-       from qiskit.circuit import Parameter
-       from qiskit.circuit.library import QuantumVolume
-       from qiskit.circuit.library.standard_gates import RXGate
-
-       from qiskit.transpiler.passes import RXCalibrationBuilder
-
-       qv = QuantumVolume(4, 4, seed=1004)
-
-       # Transpiling with single pulse RX gates enabled
-       backend_with_single_pulse_rx = GenericBackendV2(5)
-       rx_inst_props = {}
-       for i in range(backend_with_single_pulse_rx.num_qubits):
-         rx_inst_props[(i,)] = None
-       backend_with_single_pulse_rx.target.add_instruction(RXGate(Parameter("theta")), rx_inst_props)
-       config_with_rx = PassManagerConfig.from_backend(backend=backend_with_single_pulse_rx)
-       pm_with_rx = level_1_pass_manager(pass_manager_config=config_with_rx)
-       rx_builder = RXCalibrationBuilder(target=backend_with_single_pulse_rx.target)
-       pm_with_rx.post_optimization = PassManager([rx_builder])
-       transpiled_circ_with_single_pulse_rx = pm_with_rx.run(qv)
-       transpiled_circ_with_single_pulse_rx.count_ops()
-
-       # Conventional transpilation: each RX gate is decomposed into a sequence with two SX gates
-       original_backend = GenericBackendV2(5)
-       original_config = PassManagerConfig.from_backend(backend=original_backend)
-       original_pm = level_1_pass_manager(pass_manager_config=original_config)
-       original_transpiled_circ = original_pm.run(qv)
-       original_transpiled_circ.count_ops()
-
-    References
-        * [1]: Gokhale et al. (2020), Optimized Quantum Compilation for
-          Near-Term Algorithms with OpenPulse.
-          `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`
-    """
-
-    @deprecate_pulse_dependency
-    def __init__(
-        self,
-        target: Target = None,
-    ):
-        """Bootstrap single-pulse RX gate calibrations from the
-        (hardware-calibrated) SX gate calibration.
-
-        Args:
-            target (Target): Should contain a SX calibration that will be
-            used for bootstrapping RX calibrations.
-        """
-        from qiskit.transpiler.passes.optimization import NormalizeRXAngle
-
-        super().__init__()
-        self.target = target
-        self.already_generated = {}
-        self.requires = [NormalizeRXAngle(self.target)]
-
-    def supported(self, node_op: Instruction, qubits: list) -> bool:
-        """
-        Check if the calibration for SX gate exists and it's a single DRAG pulse.
-        """
-        return (
-            isinstance(node_op, RXGate)
-            and self.target._has_calibration("sx", tuple(qubits))
-            and (len(self.target._get_calibration("sx", tuple(qubits)).instructions) == 1)
-            and isinstance(
-                self.target._get_calibration("sx", tuple(qubits)).instructions[0][1].pulse,
-                ScalableSymbolicPulse,
-            )
-            and self.target._get_calibration("sx", tuple(qubits))
-            .instructions[0][1]
-            .pulse.pulse_type
-            == "Drag"
-        )
-
-    def get_calibration(self, node_op: Instruction, qubits: list) -> Union[Schedule, ScheduleBlock]:
-        """
-        Generate RX calibration for the rotation angle specified in node_op.
-        """
-        # already within [0, pi] by NormalizeRXAngles pass
-        angle = node_op.params[0]
-
-        try:
-            angle = float(angle)
-        except TypeError as ex:
-            raise QiskitError("Target rotation angle is not assigned.") from ex
-
-        params = (
-            self.target._get_calibration("sx", tuple(qubits))
-            .instructions[0][1]
-            .pulse.parameters.copy()
-        )
-        new_rx_sched = _create_rx_sched(
-            rx_angle=angle,
-            channel=self.target._get_calibration("sx", tuple(qubits)).channels[0],
-            duration=params["duration"],
-            amp=params["amp"],
-            sigma=params["sigma"],
-            beta=params["beta"],
-        )
-
-        return new_rx_sched
-
-
-@lru_cache
-def _create_rx_sched(
-    rx_angle: float,
-    duration: int,
-    amp: float,
-    sigma: float,
-    beta: float,
-    channel: Channel,
-):
-    """Generates (and caches) pulse calibrations for RX gates.
-    Assumes that the rotation angle is in [0, pi].
-    """
-    new_amp = rx_angle / (np.pi / 2) * amp
-    with builder.build() as new_rx_sched:
-        builder.play(
-            Drag(duration=duration, amp=new_amp, sigma=sigma, beta=beta, angle=0),
-            channel=channel,
-        )
-
-    return new_rx_sched

qiskit/transpiler/passes/calibration/rzx_builder.py

@@ -1,411 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""RZX calibration builders."""
-from __future__ import annotations
-
-import enum
-import math
-import warnings
-from collections.abc import Sequence
-from math import pi, erf
-
-import numpy as np
-from qiskit.circuit import Instruction as CircuitInst
-from qiskit.circuit.library.standard_gates import RZXGate
-from qiskit.exceptions import QiskitError
-from qiskit.pulse import (
-    Play,
-    Schedule,
-    ScheduleBlock,
-    ControlChannel,
-    DriveChannel,
-    GaussianSquare,
-    Waveform,
-)
-from qiskit.pulse import builder
-from qiskit.pulse.filters import filter_instructions
-from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
-from qiskit.transpiler.target import Target
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-from .base_builder import CalibrationBuilder
-from .exceptions import CalibrationNotAvailable
-
-
-class CRCalType(enum.Enum):
-    """Estimated calibration type of backend cross resonance operations."""
-
-    ECR_FORWARD = "Echoed Cross Resonance corresponding to native operation"
-    ECR_REVERSE = "Echoed Cross Resonance reverse of native operation"
-    ECR_CX_FORWARD = "Echoed Cross Resonance CX corresponding to native operation"
-    ECR_CX_REVERSE = "Echoed Cross Resonance CX reverse of native operation"
-    DIRECT_CX_FORWARD = "Direct CX corresponding to native operation"
-    DIRECT_CX_REVERSE = "Direct CX reverse of native operation"
-
-
-class RZXCalibrationBuilder(CalibrationBuilder):
-    """
-    Creates calibrations for RZXGate(theta) by stretching and compressing
-    Gaussian square pulses in the CX gate. This is done by retrieving (for a given pair of
-    qubits) the CX schedule in the instruction schedule map of the backend defaults.
-    The CX schedule must be an echoed cross-resonance gate optionally with rotary tones.
-    The cross-resonance drive tones and rotary pulses must be Gaussian square pulses.
-    The width of the Gaussian square pulse is adjusted so as to match the desired rotation angle.
-    If the rotation angle is small such that the width disappears then the amplitude of the
-    zero width Gaussian square pulse (i.e. a Gaussian) is reduced to reach the target rotation
-    angle. Additional details can be found in https://arxiv.org/abs/2012.11660.
-    """
-
-    @deprecate_pulse_dependency
-    def __init__(
-        self,
-        instruction_schedule_map: InstructionScheduleMap = None,
-        verbose: bool = True,
-        target: Target = None,
-    ):
-        """
-        Initializes a RZXGate calibration builder.
-
-        Args:
-            instruction_schedule_map: The :obj:`InstructionScheduleMap` object representing the
-                default pulse calibrations for the target backend
-            verbose: Set True to raise a user warning when RZX schedule cannot be built.
-            target: The :class:`~.Target` representing the target backend, if both
-                 ``instruction_schedule_map`` and this are specified then this argument will take
-                 precedence and ``instruction_schedule_map`` will be ignored.
-
-        Raises:
-            QiskitError: Instruction schedule map is not provided.
-        """
-        super().__init__()
-        self._inst_map = instruction_schedule_map
-        self._verbose = verbose
-        if target:
-            self._inst_map = target._instruction_schedule_map()
-        if self._inst_map is None:
-            raise QiskitError("Calibrations can only be added to Pulse-enabled backends")
-
-    def supported(self, node_op: CircuitInst, qubits: list) -> bool:
-        """Determine if a given node supports the calibration.
-
-        Args:
-            node_op: Target instruction object.
-            qubits: Integer qubit indices to check.
-
-        Returns:
-            Return ``True`` is calibration can be provided.
-        """
-        return isinstance(node_op, RZXGate) and (
-            "cx" in self._inst_map.instructions or "ecr" in self._inst_map.instructions
-        )
-
-    @staticmethod
-    @builder.macro
-    def rescale_cr_inst(instruction: Play, theta: float, sample_mult: int = 16) -> int:
-        """A builder macro to play stretched pulse.
-
-        Args:
-            instruction: The instruction from which to create a new shortened or lengthened pulse.
-            theta: desired angle, pi/2 is assumed to be the angle that the pulse in the given
-                play instruction implements.
-            sample_mult: All pulses must be a multiple of sample_mult.
-
-        Returns:
-            Duration of stretched pulse.
-
-        Raises:
-            QiskitError: if rotation angle is not assigned.
-        """
-        try:
-            theta = float(theta)
-        except TypeError as ex:
-            raise QiskitError("Target rotation angle is not assigned.") from ex
-
-        # This method is called for instructions which are guaranteed to play GaussianSquare pulse
-        params = instruction.pulse.parameters.copy()
-        risefall_sigma_ratio = (params["duration"] - params["width"]) / params["sigma"]
-
-        # The error function is used because the Gaussian may have chopped tails.
-        # Area is normalized by amplitude.
-        # This makes widths robust to the rounding error.
-        risefall_area = params["sigma"] * math.sqrt(2 * pi) * erf(risefall_sigma_ratio)
-        full_area = params["width"] + risefall_area
-
-        # Get estimate of target area. Assume this is pi/2 controlled rotation.
-        cal_angle = pi / 2
-        target_area = abs(theta) / cal_angle * full_area
-        new_width = target_area - risefall_area
-
-        if new_width >= 0:
-            width = new_width
-            params["amp"] *= np.sign(theta)
-        else:
-            width = 0
-            params["amp"] *= np.sign(theta) * target_area / risefall_area
-
-        round_duration = (
-            round((width + risefall_sigma_ratio * params["sigma"]) / sample_mult) * sample_mult
-        )
-        params["duration"] = round_duration
-        params["width"] = width
-
-        stretched_pulse = GaussianSquare(**params)
-        builder.play(stretched_pulse, instruction.channel)
-
-        return round_duration
-
-    def get_calibration(self, node_op: CircuitInst, qubits: list) -> Schedule | ScheduleBlock:
-        """Builds the calibration schedule for the RZXGate(theta) with echos.
-
-        Args:
-            node_op: Instruction of the RZXGate(theta). I.e. params[0] is theta.
-            qubits: List of qubits for which to get the schedules. The first qubit is
-                the control and the second is the target.
-
-        Returns:
-            schedule: The calibration schedule for the RZXGate(theta).
-
-        Raises:
-            QiskitError: if rotation angle is not assigned.
-            QiskitError: If the control and target qubits cannot be identified.
-            CalibrationNotAvailable: RZX schedule cannot be built for input node.
-        """
-        theta = node_op.params[0]
-
-        try:
-            theta = float(theta)
-        except TypeError as ex:
-            raise QiskitError("Target rotation angle is not assigned.") from ex
-
-        if np.isclose(theta, 0.0):
-            return ScheduleBlock(name="rzx(0.000)")
-
-        cal_type, cr_tones, comp_tones = _check_calibration_type(self._inst_map, qubits)
-
-        if cal_type in [CRCalType.DIRECT_CX_FORWARD, CRCalType.DIRECT_CX_REVERSE]:
-            if self._verbose:
-                warnings.warn(
-                    f"CR instruction for qubits {qubits} is likely {cal_type.value} sequence. "
-                    "Pulse stretch for this calibration is not currently implemented. "
-                    "RZX schedule is not generated for this qubit pair.",
-                    UserWarning,
-                )
-            raise CalibrationNotAvailable
-
-        # The CR instruction is in the forward (native) direction
-        if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            with warnings.catch_warnings():
-                warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                # `InstructionScheduleMap.get` and the pulse builder emit deprecation warnings
-                # as they use classes and methods which are deprecated in Qiskit 1.3 as part of the
-                # Qiskit Pulse deprecation
-                xgate = self._inst_map.get("x", qubits[0])
-                with builder.build(
-                    default_alignment="sequential", name=f"rzx({theta:.3f})"
-                ) as rzx_theta_native:
-                    for cr_tone, comp_tone in zip(cr_tones, comp_tones):
-                        with builder.align_left():
-                            self.rescale_cr_inst(cr_tone, theta)
-                            self.rescale_cr_inst(comp_tone, theta)
-                        builder.call(xgate)
-            return rzx_theta_native
-
-        # The direction is not native. Add Hadamard gates to flip the direction.
-        xgate = self._inst_map.get("x", qubits[1])
-        szc = self._inst_map.get("rz", qubits[1], pi / 2)
-        sxc = self._inst_map.get("sx", qubits[1])
-        szt = self._inst_map.get("rz", qubits[0], pi / 2)
-        sxt = self._inst_map.get("sx", qubits[0])
-        with builder.build(name="hadamard") as hadamard:
-            # Control qubit
-            builder.call(szc, name="szc")
-            builder.call(sxc, name="sxc")
-            builder.call(szc, name="szc")
-            # Target qubit
-            builder.call(szt, name="szt")
-            builder.call(sxt, name="sxt")
-            builder.call(szt, name="szt")
-
-        with builder.build(
-            default_alignment="sequential", name=f"rzx({theta:.3f})"
-        ) as rzx_theta_flip:
-            builder.call(hadamard, name="hadamard")
-            for cr_tone, comp_tone in zip(cr_tones, comp_tones):
-                with builder.align_left():
-                    self.rescale_cr_inst(cr_tone, theta)
-                    self.rescale_cr_inst(comp_tone, theta)
-                builder.call(xgate)
-            builder.call(hadamard, name="hadamard")
-        return rzx_theta_flip
-
-
-class RZXCalibrationBuilderNoEcho(RZXCalibrationBuilder):
-    """
-    Creates calibrations for RZXGate(theta) by stretching and compressing
-    Gaussian square pulses in the CX gate.
-
-    The ``RZXCalibrationBuilderNoEcho`` is a variation of the
-    :class:`~qiskit.transpiler.passes.RZXCalibrationBuilder` pass
-    that creates calibrations for the cross-resonance pulses without inserting
-    the echo pulses in the pulse schedule. This enables exposing the echo in
-    the cross-resonance sequence as gates so that the transpiler can simplify them.
-    The ``RZXCalibrationBuilderNoEcho`` only supports the hardware-native direction
-    of the CX gate.
-    """
-
-    def get_calibration(self, node_op: CircuitInst, qubits: list) -> Schedule | ScheduleBlock:
-        """Builds the calibration schedule for the RZXGate(theta) without echos.
-
-        Args:
-            node_op: Instruction of the RZXGate(theta). I.e. params[0] is theta.
-            qubits: List of qubits for which to get the schedules. The first qubit is
-                the control and the second is the target.
-
-        Returns:
-            schedule: The calibration schedule for the RZXGate(theta).
-
-        Raises:
-            QiskitError: if rotation angle is not assigned.
-            QiskitError: If the control and target qubits cannot be identified,
-                or the backend does not natively support the specified direction of the cx.
-            CalibrationNotAvailable: RZX schedule cannot be built for input node.
-        """
-        theta = node_op.params[0]
-
-        try:
-            theta = float(theta)
-        except TypeError as ex:
-            raise QiskitError("Target rotation angle is not assigned.") from ex
-
-        if np.isclose(theta, 0.0):
-            return ScheduleBlock(name="rzx(0.000)")
-
-        cal_type, cr_tones, comp_tones = _check_calibration_type(self._inst_map, qubits)
-
-        if cal_type in [CRCalType.DIRECT_CX_FORWARD, CRCalType.DIRECT_CX_REVERSE]:
-            if self._verbose:
-                warnings.warn(
-                    f"CR instruction for qubits {qubits} is likely {cal_type.value} sequence. "
-                    "Pulse stretch for this calibration is not currently implemented. "
-                    "RZX schedule is not generated for this qubit pair.",
-                    UserWarning,
-                )
-            raise CalibrationNotAvailable
-
-        # RZXCalibrationNoEcho only good for forward CR direction
-        if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            with warnings.catch_warnings():
-                warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                # Pulse builder emits deprecation warnings as part of the
-                # Qiskit Pulse deprecation
-                with builder.build(default_alignment="left", name=f"rzx({theta:.3f})") as rzx_theta:
-                    stretched_dur = self.rescale_cr_inst(cr_tones[0], 2 * theta)
-                    self.rescale_cr_inst(comp_tones[0], 2 * theta)
-                    # Placeholder to make pulse gate work
-                    builder.delay(stretched_dur, DriveChannel(qubits[0]))
-            return rzx_theta
-
-        raise QiskitError("RZXCalibrationBuilderNoEcho only supports hardware-native RZX gates.")
-
-
-def _filter_cr_tone(time_inst_tup):
-    """A helper function to filter pulses on control channels."""
-    valid_types = ["GaussianSquare"]
-
-    _, inst = time_inst_tup
-    if isinstance(inst, Play) and isinstance(inst.channel, ControlChannel):
-        pulse = inst.pulse
-        if isinstance(pulse, Waveform) or pulse.pulse_type in valid_types:
-            return True
-    return False
-
-
-def _filter_comp_tone(time_inst_tup):
-    """A helper function to filter pulses on drive channels."""
-    valid_types = ["GaussianSquare"]
-
-    _, inst = time_inst_tup
-    if isinstance(inst, Play) and isinstance(inst.channel, DriveChannel):
-        pulse = inst.pulse
-        if isinstance(pulse, Waveform) or pulse.pulse_type in valid_types:
-            return True
-    return False
-
-
-def _check_calibration_type(
-    inst_sched_map: InstructionScheduleMap, qubits: Sequence[int]
-) -> tuple[CRCalType, list[Play], list[Play]]:
-    """A helper function to check type of CR calibration.
-
-    Args:
-        inst_sched_map: instruction schedule map of the backends
-        qubits: ordered tuple of qubits for cross resonance (q_control, q_target)
-
-    Returns:
-        Filtered instructions and most-likely type of calibration.
-
-    Raises:
-        QiskitError: Unknown calibration type is detected.
-    """
-    cal_type = None
-    with warnings.catch_warnings():
-        warnings.simplefilter(action="ignore", category=DeprecationWarning)
-        # `InstructionScheduleMap.get` and `filter_instructions` emit deprecation warnings
-        # as they use classes and methods which are deprecated in Qiskit 1.3 as part of the
-        # Qiskit Pulse deprecation
-        if inst_sched_map.has("cx", qubits):
-            cr_sched = inst_sched_map.get("cx", qubits=qubits)
-        elif inst_sched_map.has("ecr", qubits):
-            cr_sched = inst_sched_map.get("ecr", qubits=qubits)
-            cal_type = CRCalType.ECR_FORWARD
-        elif inst_sched_map.has("ecr", tuple(reversed(qubits))):
-            cr_sched = inst_sched_map.get("ecr", tuple(reversed(qubits)))
-            cal_type = CRCalType.ECR_REVERSE
-        else:
-            raise QiskitError(
-                f"Native direction cannot be determined: operation on qubits {qubits} "
-                f"for the following instruction schedule map:\n{inst_sched_map}"
-            )
-
-        cr_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_cr_tone]).instructions]
-        comp_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_comp_tone]).instructions]
-
-    if cal_type is None:
-        if len(comp_tones) == 0:
-            raise QiskitError(
-                f"{repr(cr_sched)} has no target compensation tones. "
-                "Native ECR direction cannot be determined."
-            )
-        # Determine native direction, assuming only single drive channel per qubit.
-        # This guarantees channel and qubit index equality.
-        if comp_tones[0].channel.index == qubits[1]:
-            cal_type = CRCalType.ECR_CX_FORWARD
-        else:
-            cal_type = CRCalType.ECR_CX_REVERSE
-
-    if len(cr_tones) == 2 and len(comp_tones) in (0, 2):
-        # ECR can be implemented without compensation tone at price of lower fidelity.
-        # Remarkable noisy terms are usually eliminated by echo.
-        return cal_type, cr_tones, comp_tones
-
-    if len(cr_tones) == 1 and len(comp_tones) == 1:
-        # Direct CX must have compensation tone on target qubit.
-        # Otherwise, it cannot eliminate IX interaction.
-        if comp_tones[0].channel.index == qubits[1]:
-            return CRCalType.DIRECT_CX_FORWARD, cr_tones, comp_tones
-        else:
-            return CRCalType.DIRECT_CX_REVERSE, cr_tones, comp_tones
-    raise QiskitError(
-        f"{repr(cr_sched)} is undefined pulse sequence. "
-        "Check if this is a calibration for cross resonance operation."
-    )