qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/visualization/pulse_v2/device_info.py

@@ -1,173 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# 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.
-
-"""A collection of backend information formatted to generate drawing data.
-
-This instance will be provided to generator functions. The module provides an abstract
-class :py:class:``DrawerBackendInfo`` with necessary methods to generate drawing objects.
-
-Because the data structure of backend class may depend on providers, this abstract class
-has an abstract factory method `create_from_backend`. Each subclass should provide
-the factory method which conforms to the associated provider. By default we provide
-:py:class:``OpenPulseBackendInfo`` class that has the factory method taking backends
-satisfying OpenPulse specification [1].
-
-This class can be also initialized without the factory method by manually specifying
-required information. This may be convenient for visualizing a pulse program for simulator
-backend that only has a device Hamiltonian information. This requires two mapping objects
-for channel/qubit and channel/frequency along with the system cycle time.
-
-If those information are not provided, this class will be initialized with a set of
-empty data and the drawer illustrates a pulse program without any specific information.
-
-Reference:
-- [1] Qiskit Backend Specifications for OpenQASM and OpenPulse Experiments,
-    https://arxiv.org/abs/1809.03452
-"""
-
-from abc import ABC, abstractmethod
-from collections import defaultdict
-from typing import Dict, List, Union, Optional
-
-from qiskit import pulse
-from qiskit.providers import BackendConfigurationError
-from qiskit.providers.backend import Backend, BackendV2
-
-
-class DrawerBackendInfo(ABC):
-    """Backend information to be used for the drawing data generation."""
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        dt: Optional[float] = None,
-        channel_frequency_map: Optional[Dict[pulse.channels.Channel, float]] = None,
-        qubit_channel_map: Optional[Dict[int, List[pulse.channels.Channel]]] = None,
-    ):
-        """Create new backend information.
-
-        Args:
-            name: Name of the backend.
-            dt: System cycle time.
-            channel_frequency_map: Mapping of channel and associated frequency.
-            qubit_channel_map: Mapping of qubit and associated channels.
-        """
-        self.backend_name = name or "no-backend"
-        self._dt = dt
-        self._chan_freq_map = channel_frequency_map or {}
-        self._qubit_channel_map = qubit_channel_map or {}
-
-    @classmethod
-    @abstractmethod
-    def create_from_backend(cls, backend: Backend):
-        """Initialize a class with backend information provided by provider.
-
-        Args:
-            backend: Backend object.
-        """
-        raise NotImplementedError
-
-    @property
-    def dt(self):
-        """Return cycle time."""
-        return self._dt
-
-    def get_qubit_index(self, chan: pulse.channels.Channel) -> Union[int, None]:
-        """Get associated qubit index of given channel object."""
-        for qind, chans in self._qubit_channel_map.items():
-            if chan in chans:
-                return qind
-        return chan.index
-
-    def get_channel_frequency(self, chan: pulse.channels.Channel) -> Union[float, None]:
-        """Get frequency of given channel object."""
-        return self._chan_freq_map.get(chan, None)
-
-
-class OpenPulseBackendInfo(DrawerBackendInfo):
-    """Drawing information of backend that conforms to OpenPulse specification."""
-
-    @classmethod
-    def create_from_backend(cls, backend: Backend):
-        """Initialize a class with backend information provided by provider.
-
-        Args:
-            backend: Backend object.
-
-        Returns:
-            OpenPulseBackendInfo: New configured instance.
-        """
-        chan_freqs = {}
-        qubit_channel_map = defaultdict(list)
-
-        if hasattr(backend, "configuration") and hasattr(backend, "defaults"):
-            configuration = backend.configuration()
-            defaults = backend.defaults()
-
-            name = configuration.backend_name
-            dt = configuration.dt
-
-            # load frequencies
-            chan_freqs.update(
-                {
-                    pulse.DriveChannel(qind): freq
-                    for qind, freq in enumerate(defaults.qubit_freq_est)
-                }
-            )
-            chan_freqs.update(
-                {
-                    pulse.MeasureChannel(qind): freq
-                    for qind, freq in enumerate(defaults.meas_freq_est)
-                }
-            )
-            for qind, u_lo_mappers in enumerate(configuration.u_channel_lo):
-                temp_val = 0.0 + 0.0j
-                for u_lo_mapper in u_lo_mappers:
-                    temp_val += defaults.qubit_freq_est[u_lo_mapper.q] * u_lo_mapper.scale
-                chan_freqs[pulse.ControlChannel(qind)] = temp_val.real
-
-            # load qubit channel mapping
-            for qind in range(configuration.n_qubits):
-                qubit_channel_map[qind].append(configuration.drive(qubit=qind))
-                qubit_channel_map[qind].append(configuration.measure(qubit=qind))
-                for tind in range(configuration.n_qubits):
-                    try:
-                        qubit_channel_map[qind].extend(configuration.control(qubits=(qind, tind)))
-                    except BackendConfigurationError:
-                        pass
-        elif isinstance(backend, BackendV2):
-            # Pure V2 model doesn't contain channel frequency information.
-            name = backend.name
-            dt = backend.dt
-
-            # load qubit channel mapping
-            for qind in range(backend.num_qubits):
-                # channels are NotImplemented by default so we must catch arbitrary error.
-                try:
-                    qubit_channel_map[qind].append(backend.drive_channel(qind))
-                except Exception:  # pylint: disable=broad-except
-                    pass
-                try:
-                    qubit_channel_map[qind].append(backend.measure_channel(qind))
-                except Exception:  # pylint: disable=broad-except
-                    pass
-                for tind in range(backend.num_qubits):
-                    try:
-                        qubit_channel_map[qind].extend(backend.control_channel(qubits=(qind, tind)))
-                    except Exception:  # pylint: disable=broad-except
-                        pass
-        else:
-            raise RuntimeError("Backend object not yet supported")
-
-        return OpenPulseBackendInfo(
-            name=name, dt=dt, channel_frequency_map=chan_freqs, qubit_channel_map=qubit_channel_map
-        )

qiskit/visualization/pulse_v2/drawings.py

@@ -1,253 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# 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.
-
-"""
-Drawing objects for pulse drawer.
-
-Drawing objects play two important roles:
-    - Allowing unittests of visualization module. Usually it is hard for image files to be tested.
-    - Removing program parser from each plotter interface. We can easily add new plotter.
-
-This module is based on the structure of matplotlib as it is the primary plotter
-of the pulse drawer. However this interface is agnostic to the actual plotter.
-
-Design concept
-~~~~~~~~~~~~~~
-When we think about dynamically updating drawings, it will be most efficient to
-update only the changed properties of drawings rather than regenerating entirely from scratch.
-Thus the core :py:class:`qiskit.visualization.pulse_v2.core.DrawerCanvas` generates
-all possible drawings in the beginning and then the canvas instance manages
-visibility of each drawing according to the end-user request.
-
-Data key
-~~~~~~~~
-In the abstract class ``ElementaryData`` common attributes to represent a drawing are
-specified. In addition, drawings have the `data_key` property that returns an
-unique hash of the object for comparison.
-This key is generated from a data type and the location of the drawing in the canvas.
-See py:mod:`qiskit.visualization.pulse_v2.types` for detail on the data type.
-If a data key cannot distinguish two independent objects, you need to add a new data type.
-The data key may be used in the plotter interface to identify the object.
-
-Drawing objects
-~~~~~~~~~~~~~~~
-To support not only `matplotlib` but also multiple plotters, those drawings should be
-universal and designed without strong dependency on modules in `matplotlib`.
-This means drawings that represent primitive geometries are preferred.
-It should be noted that there will be no unittest for each plotter API, which takes
-drawings and outputs image data, we should avoid adding a complicated geometry
-that has a context of the pulse program.
-
-For example, a pulse envelope is complex valued number array and may be represented
-by two lines with different colors associated with the real and the imaginary component.
-We can use two line-type objects rather than defining a new drawing that takes
-complex value. As many plotters don't support an API that visualizes complex-valued
-data arrays, if we introduced such a drawing and wrote a custom wrapper function
-on top of the existing API, it could be difficult to prevent bugs with the CI tools
-due to lack of the effective unittest.
-"""
-from __future__ import annotations
-
-from abc import ABC
-from enum import Enum
-from typing import Any
-
-import numpy as np
-
-from qiskit.pulse.channels import Channel
-from qiskit.visualization.pulse_v2 import types
-from qiskit.visualization.exceptions import VisualizationError
-
-
-class ElementaryData(ABC):
-    """Base class of the pulse visualization interface."""
-
-    __hash__ = None
-
-    def __init__(
-        self,
-        data_type: str | Enum,
-        xvals: np.ndarray,
-        yvals: np.ndarray,
-        channels: Channel | list[Channel] | None = None,
-        meta: dict[str, Any] | None = None,
-        ignore_scaling: bool = False,
-        styles: dict[str, Any] | None = None,
-    ):
-        """Create new drawing.
-
-        Args:
-            data_type: String representation of this drawing.
-            xvals: Series of horizontal coordinate that the object is drawn.
-            yvals: Series of vertical coordinate that the object is drawn.
-            channels: Pulse channel object bound to this drawing.
-            meta: Meta data dictionary of the object.
-            ignore_scaling: Set ``True`` to disable scaling.
-            styles: Style keyword args of the object. This conforms to `matplotlib`.
-        """
-        if channels and isinstance(channels, Channel):
-            channels = [channels]
-
-        if isinstance(data_type, Enum):
-            data_type = data_type.value
-
-        self.data_type = str(data_type)
-        self.xvals = np.array(xvals, dtype=object)
-        self.yvals = np.array(yvals, dtype=object)
-        self.channels: list[Channel] = channels or []
-        self.meta = meta or {}
-        self.ignore_scaling = ignore_scaling
-        self.styles = styles or {}
-
-    @property
-    def data_key(self):
-        """Return unique hash of this object."""
-        return str(
-            hash((self.__class__.__name__, self.data_type, tuple(self.xvals), tuple(self.yvals)))
-        )
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}(type={self.data_type}, key={self.data_key})"
-
-    def __eq__(self, other):
-        return isinstance(other, self.__class__) and self.data_key == other.data_key
-
-
-class LineData(ElementaryData):
-    """Drawing object to represent object appears as a line.
-
-    This is the counterpart of `matplotlib.pyplot.plot`.
-    """
-
-    def __init__(
-        self,
-        data_type: str | Enum,
-        xvals: np.ndarray | list[types.Coordinate],
-        yvals: np.ndarray | list[types.Coordinate],
-        fill: bool = False,
-        channels: Channel | list[Channel] | None = None,
-        meta: dict[str, Any] | None = None,
-        ignore_scaling: bool = False,
-        styles: dict[str, Any] | None = None,
-    ):
-        """Create new drawing.
-
-        Args:
-            data_type: String representation of this drawing.
-            channels: Pulse channel object bound to this drawing.
-            xvals: Series of horizontal coordinate that the object is drawn.
-            yvals: Series of vertical coordinate that the object is drawn.
-            fill: Set ``True`` to fill the area under curve.
-            meta: Meta data dictionary of the object.
-            ignore_scaling: Set ``True`` to disable scaling.
-            styles: Style keyword args of the object. This conforms to `matplotlib`.
-        """
-        self.fill = fill
-
-        super().__init__(
-            data_type=data_type,
-            xvals=xvals,
-            yvals=yvals,
-            channels=channels,
-            meta=meta,
-            ignore_scaling=ignore_scaling,
-            styles=styles,
-        )
-
-
-class TextData(ElementaryData):
-    """Drawing object to represent object appears as a text.
-
-    This is the counterpart of `matplotlib.pyplot.text`.
-    """
-
-    def __init__(
-        self,
-        data_type: str | Enum,
-        xvals: np.ndarray | list[types.Coordinate],
-        yvals: np.ndarray | list[types.Coordinate],
-        text: str,
-        latex: str | None = None,
-        channels: Channel | list[Channel] | None = None,
-        meta: dict[str, Any] | None = None,
-        ignore_scaling: bool = False,
-        styles: dict[str, Any] | None = None,
-    ):
-        """Create new drawing.
-
-        Args:
-            data_type: String representation of this drawing.
-            channels: Pulse channel object bound to this drawing.
-            xvals: Series of horizontal coordinate that the object is drawn.
-            yvals: Series of vertical coordinate that the object is drawn.
-            text: String to show in the canvas.
-            latex: Latex representation of the text (if backend supports latex drawing).
-            meta: Meta data dictionary of the object.
-            ignore_scaling: Set ``True`` to disable scaling.
-            styles: Style keyword args of the object. This conforms to `matplotlib`.
-        """
-        self.text = text
-        self.latex = latex or ""
-
-        super().__init__(
-            data_type=data_type,
-            xvals=xvals,
-            yvals=yvals,
-            channels=channels,
-            meta=meta,
-            ignore_scaling=ignore_scaling,
-            styles=styles,
-        )
-
-
-class BoxData(ElementaryData):
-    """Drawing object that represents box shape.
-
-    This is the counterpart of `matplotlib.patches.Rectangle`.
-    """
-
-    def __init__(
-        self,
-        data_type: str | Enum,
-        xvals: np.ndarray | list[types.Coordinate],
-        yvals: np.ndarray | list[types.Coordinate],
-        channels: Channel | list[Channel] | None = None,
-        meta: dict[str, Any] | None = None,
-        ignore_scaling: bool = False,
-        styles: dict[str, Any] | None = None,
-    ):
-        """Create new box.
-
-        Args:
-            data_type: String representation of this drawing.
-            xvals: Left and right coordinate that the object is drawn.
-            yvals: Top and bottom coordinate that the object is drawn.
-            channels: Pulse channel object bound to this drawing.
-            meta: Meta data dictionary of the object.
-            ignore_scaling: Set ``True`` to disable scaling.
-            styles: Style keyword args of the object. This conforms to `matplotlib`.
-
-        Raises:
-            VisualizationError: When number of data points are not equals to 2.
-        """
-        if len(xvals) != 2 or len(yvals) != 2:
-            raise VisualizationError("Length of data points are not equals to 2.")
-
-        super().__init__(
-            data_type=data_type,
-            xvals=xvals,
-            yvals=yvals,
-            channels=channels,
-            meta=meta,
-            ignore_scaling=ignore_scaling,
-            styles=styles,
-        )

qiskit/visualization/pulse_v2/events.py

@@ -1,254 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# 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.
-
-r"""
-Channel event manager for pulse schedules.
-
-This module provides a `ChannelEvents` class that manages a series of instructions for a
-pulse channel. Channel-wise filtering of the pulse program makes
-the arrangement of channels easier in the core drawer function.
-The `ChannelEvents` class is expected to be called by other programs (not by end-users).
-
-The `ChannelEvents` class instance is created with the class method ``load_program``:
-
-.. code-block:: python
-
-    event = ChannelEvents.load_program(sched, DriveChannel(0))
-
-The `ChannelEvents` is created for a specific pulse channel and loosely assorts pulse
-instructions within the channel with different visualization purposes.
-
-Phase and frequency related instructions are loosely grouped as frame changes.
-The instantaneous value of those operands are combined and provided as ``PhaseFreqTuple``.
-Instructions that have finite duration are grouped as waveforms.
-
-The grouped instructions are returned as an iterator by the corresponding method call:
-
-.. code-block:: python
-
-    for t0, frame, instruction in event.get_waveforms():
-        ...
-
-    for t0, frame_change, instructions in event.get_frame_changes():
-        ...
-
-The class method ``get_waveforms`` returns the iterator of waveform type instructions with
-the ``PhaseFreqTuple`` (frame) at the time when instruction is issued.
-This is because a pulse envelope of ``Waveform`` may be modulated with a
-phase factor $exp(-i \omega t - \phi)$ with frequency $\omega$ and phase $\phi$ and
-appear on the canvas. Thus, it is better to tell users in which phase and frequency
-the pulse envelope is modulated from a viewpoint of program debugging.
-
-On the other hand, the class method ``get_frame_changes`` returns a ``PhaseFreqTuple`` that
-represents a total amount of change at that time because it is convenient to know
-the operand value itself when we debug a program.
-
-Because frame change type instructions are usually zero duration, multiple instructions
-can be issued at the same time and those operand values should be appropriately
-combined. In Qiskit Pulse we have set and shift type instructions for the frame control,
-the set type instruction will be converted into the relevant shift amount for visualization.
-Note that these instructions are not interchangeable and the order should be kept.
-For example:
-
-.. code-block:: python
-
-    sched1 = Schedule()
-    sched1 = sched1.insert(0, ShiftPhase(-1.57, DriveChannel(0))
-    sched1 = sched1.insert(0, SetPhase(3.14, DriveChannel(0))
-
-    sched2 = Schedule()
-    sched2 = sched2.insert(0, SetPhase(3.14, DriveChannel(0))
-    sched2 = sched2.insert(0, ShiftPhase(-1.57, DriveChannel(0))
-
-In this example, ``sched1`` and ``sched2`` will have different frames.
-On the drawer canvas, the total frame change amount of +3.14 should be shown for ``sched1``,
-while ``sched2`` is +1.57. Since the `SetPhase` and the `ShiftPhase` instruction behave
-differently, we cannot simply sum up the operand values in visualization output.
-
-It should be also noted that zero duration instructions issued at the same time will be
-overlapped on the canvas. Thus it is convenient to plot a total frame change amount rather
-than plotting each operand value bound to the instruction.
-"""
-from __future__ import annotations
-from collections import defaultdict
-from collections.abc import Iterator
-
-from qiskit import pulse, circuit
-from qiskit.visualization.pulse_v2.types import PhaseFreqTuple, PulseInstruction
-
-
-class ChannelEvents:
-    """Channel event manager."""
-
-    _waveform_group = (
-        pulse.instructions.Play,
-        pulse.instructions.Delay,
-        pulse.instructions.Acquire,
-    )
-    _frame_group = (
-        pulse.instructions.SetFrequency,
-        pulse.instructions.ShiftFrequency,
-        pulse.instructions.SetPhase,
-        pulse.instructions.ShiftPhase,
-    )
-
-    def __init__(
-        self,
-        waveforms: dict[int, pulse.Instruction],
-        frames: dict[int, list[pulse.Instruction]],
-        channel: pulse.channels.Channel,
-    ):
-        """Create new event manager.
-
-        Args:
-            waveforms: List of waveforms shown in this channel.
-            frames: List of frame change type instructions shown in this channel.
-            channel: Channel object associated with this manager.
-        """
-        self._waveforms = waveforms
-        self._frames = frames
-        self.channel = channel
-
-        # initial frame
-        self._init_phase = 0.0
-        self._init_frequency = 0.0
-
-        # time resolution
-        self._dt = 0.0
-
-    @classmethod
-    def load_program(cls, program: pulse.Schedule, channel: pulse.channels.Channel):
-        """Load a pulse program represented by ``Schedule``.
-
-        Args:
-            program: Target ``Schedule`` to visualize.
-            channel: The channel managed by this instance.
-
-        Returns:
-            ChannelEvents: The channel event manager for the specified channel.
-        """
-        waveforms = {}
-        frames = defaultdict(list)
-
-        # parse instructions
-        for t0, inst in program.filter(channels=[channel]).instructions:
-            if isinstance(inst, cls._waveform_group):
-                if inst.duration == 0:
-                    # special case, duration of delay can be zero
-                    continue
-                waveforms[t0] = inst
-            elif isinstance(inst, cls._frame_group):
-                frames[t0].append(inst)
-
-        return ChannelEvents(waveforms, frames, channel)
-
-    def set_config(self, dt: float, init_frequency: float, init_phase: float):
-        """Setup system status.
-
-        Args:
-            dt: Time resolution in sec.
-            init_frequency: Modulation frequency in Hz.
-            init_phase: Initial phase in rad.
-        """
-        self._dt = dt or 1.0
-        self._init_frequency = init_frequency or 0.0
-        self._init_phase = init_phase or 0.0
-
-    def get_waveforms(self) -> Iterator[PulseInstruction]:
-        """Return waveform type instructions with frame."""
-        sorted_frame_changes = sorted(self._frames.items(), key=lambda x: x[0], reverse=True)
-        sorted_waveforms = sorted(self._waveforms.items(), key=lambda x: x[0])
-
-        # bind phase and frequency with instruction
-        phase = self._init_phase
-        frequency = self._init_frequency
-        for t0, inst in sorted_waveforms:
-            is_opaque = False
-
-            while len(sorted_frame_changes) > 0 and sorted_frame_changes[-1][0] <= t0:
-                _, frame_changes = sorted_frame_changes.pop()
-                phase, frequency = ChannelEvents._calculate_current_frame(
-                    frame_changes=frame_changes, phase=phase, frequency=frequency
-                )
-
-            # Convert parameter expression into float
-            if isinstance(phase, circuit.ParameterExpression):
-                phase = float(phase.bind({param: 0 for param in phase.parameters}))
-            if isinstance(frequency, circuit.ParameterExpression):
-                frequency = float(frequency.bind({param: 0 for param in frequency.parameters}))
-
-            frame = PhaseFreqTuple(phase, frequency)
-
-            # Check if pulse has unbound parameters
-            if isinstance(inst, pulse.Play):
-                is_opaque = inst.pulse.is_parameterized()
-
-            yield PulseInstruction(t0, self._dt, frame, inst, is_opaque)
-
-    def get_frame_changes(self) -> Iterator[PulseInstruction]:
-        """Return frame change type instructions with total frame change amount."""
-        # TODO parse parametrized FCs correctly
-
-        sorted_frame_changes = sorted(self._frames.items(), key=lambda x: x[0])
-
-        phase = self._init_phase
-        frequency = self._init_frequency
-        for t0, frame_changes in sorted_frame_changes:
-            is_opaque = False
-
-            pre_phase = phase
-            pre_frequency = frequency
-            phase, frequency = ChannelEvents._calculate_current_frame(
-                frame_changes=frame_changes, phase=phase, frequency=frequency
-            )
-
-            # keep parameter expression to check either phase or frequency is parameterized
-            frame = PhaseFreqTuple(phase - pre_phase, frequency - pre_frequency)
-
-            # remove parameter expressions to find if next frame is parameterized
-            if isinstance(phase, circuit.ParameterExpression):
-                phase = float(phase.bind({param: 0 for param in phase.parameters}))
-                is_opaque = True
-            if isinstance(frequency, circuit.ParameterExpression):
-                frequency = float(frequency.bind({param: 0 for param in frequency.parameters}))
-                is_opaque = True
-
-            yield PulseInstruction(t0, self._dt, frame, frame_changes, is_opaque)
-
-    @classmethod
-    def _calculate_current_frame(
-        cls, frame_changes: list[pulse.instructions.Instruction], phase: float, frequency: float
-    ) -> tuple[float, float]:
-        """Calculate the current frame from the previous frame.
-
-        If parameter is unbound phase or frequency accumulation with this instruction is skipped.
-
-        Args:
-            frame_changes: List of frame change instructions at a specific time.
-            phase: Phase of previous frame.
-            frequency: Frequency of previous frame.
-
-        Returns:
-            Phase and frequency of new frame.
-        """
-
-        for frame_change in frame_changes:
-            if isinstance(frame_change, pulse.instructions.SetFrequency):
-                frequency = frame_change.frequency
-            elif isinstance(frame_change, pulse.instructions.ShiftFrequency):
-                frequency += frame_change.frequency
-            elif isinstance(frame_change, pulse.instructions.SetPhase):
-                phase = frame_change.phase
-            elif isinstance(frame_change, pulse.instructions.ShiftPhase):
-                phase += frame_change.phase
-
-        return phase, frequency