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

qiskit/visualization/pulse_v2/generators/frame.py

@@ -1,436 +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.
-
-# pylint: disable=unused-argument
-
-"""Frame change generators.
-
-A collection of functions that generate drawings from formatted input data.
-See py:mod:`qiskit.visualization.pulse_v2.types` for more info on the required data.
-
-In this module the input data is `types.PulseInstruction`.
-
-An end-user can write arbitrary functions that generate custom drawings.
-Generators in this module are called with the `formatter` and `device` kwargs.
-These data provides stylesheet configuration and backend system configuration.
-
-The format of generator is restricted to:
-
-    ```python
-
-    def my_object_generator(data: PulseInstruction,
-                            formatter: Dict[str, Any],
-                            device: DrawerBackendInfo) -> List[ElementaryData]:
-        pass
-    ```
-
-Arbitrary generator function satisfying the above format can be accepted.
-Returned `ElementaryData` can be arbitrary subclasses that are implemented in
-the plotter API.
-"""
-from fractions import Fraction
-from typing import Dict, Any, List, Tuple
-
-import numpy as np
-from qiskit.pulse import instructions
-from qiskit.visualization.exceptions import VisualizationError
-from qiskit.visualization.pulse_v2 import drawings, types, device_info
-
-
-def gen_formatted_phase(
-    data: types.PulseInstruction, formatter: Dict[str, Any], device: device_info.DrawerBackendInfo
-) -> List[drawings.TextData]:
-    """Generate the formatted virtual Z rotation label from provided frame instruction.
-
-    Rotation angle is expressed in units of pi.
-    If the denominator of fraction is larger than 10, the angle is expressed in units of radian.
-
-    For example:
-        - A value -3.14 is converted into `VZ(\\pi)`
-        - A value 1.57 is converted into `VZ(-\\frac{\\pi}{2})`
-        - A value 0.123 is converted into `VZ(-0.123 rad.)`
-
-    Stylesheets:
-        - The `frame_change` style is applied.
-        - The `annotate` style is applied for font size.
-
-    Notes:
-        The phase operand of `PhaseShift` instruction has opposite sign to the Z gate definition.
-        Thus the sign of rotation angle is inverted.
-
-    Args:
-        data: Frame change instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    _max_denom = 10
-
-    style = {
-        "zorder": formatter["layer.frame_change"],
-        "color": formatter["color.frame_change"],
-        "size": formatter["text_size.annotate"],
-        "va": "center",
-        "ha": "center",
-    }
-
-    plain_phase, latex_phase = _phase_to_text(
-        formatter=formatter, phase=data.frame.phase, max_denom=_max_denom, flip=True
-    )
-
-    text = drawings.TextData(
-        data_type=types.LabelType.FRAME,
-        channels=data.inst[0].channel,
-        xvals=[data.t0],
-        yvals=[formatter["label_offset.frame_change"]],
-        text=f"VZ({plain_phase})",
-        latex=rf"{{\rm VZ}}({latex_phase})",
-        ignore_scaling=True,
-        styles=style,
-    )
-
-    return [text]
-
-
-def gen_formatted_freq_mhz(
-    data: types.PulseInstruction, formatter: Dict[str, Any], device: device_info.DrawerBackendInfo
-) -> List[drawings.TextData]:
-    """Generate the formatted frequency change label from provided frame instruction.
-
-    Frequency change is expressed in units of MHz.
-
-    For example:
-        - A value 1,234,567 is converted into `\\Delta f = 1.23 MHz`
-
-    Stylesheets:
-        - The `frame_change` style is applied.
-        - The `annotate` style is applied for font size.
-
-    Args:
-        data: Frame change instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    _unit = "MHz"
-
-    style = {
-        "zorder": formatter["layer.frame_change"],
-        "color": formatter["color.frame_change"],
-        "size": formatter["text_size.annotate"],
-        "va": "center",
-        "ha": "center",
-    }
-
-    plain_freq, latex_freq = _freq_to_text(formatter=formatter, freq=data.frame.freq, unit=_unit)
-
-    text = drawings.TextData(
-        data_type=types.LabelType.FRAME,
-        channels=data.inst[0].channel,
-        xvals=[data.t0],
-        yvals=[formatter["label_offset.frame_change"]],
-        text=f"\u0394f = {plain_freq}",
-        latex=rf"\Delta f = {latex_freq}",
-        ignore_scaling=True,
-        styles=style,
-    )
-
-    return [text]
-
-
-def gen_formatted_frame_values(
-    data: types.PulseInstruction, formatter: Dict[str, Any], device: device_info.DrawerBackendInfo
-) -> List[drawings.TextData]:
-    """Generate the formatted virtual Z rotation label and the frequency change label
-    from provided frame instruction.
-
-    Phase value is placed on top of the symbol, and frequency value is placed below the symbol.
-    See :py:func:`gen_formatted_phase` and :py:func:`gen_formatted_freq_mhz` for details.
-
-    Stylesheets:
-        - The `frame_change` style is applied.
-        - The `annotate` style is applied for font size.
-
-    Args:
-        data: Frame change instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    texts = []
-
-    _max_denom = 10
-    _unit = "MHz"
-
-    style = {
-        "zorder": formatter["layer.frame_change"],
-        "color": formatter["color.frame_change"],
-        "size": formatter["text_size.annotate"],
-        "ha": "center",
-    }
-
-    # phase value
-    if data.frame.phase != 0:
-        plain_phase, latex_phase = _phase_to_text(
-            formatter=formatter, phase=data.frame.phase, max_denom=_max_denom, flip=True
-        )
-        phase_style = {"va": "center"}
-        phase_style.update(style)
-
-        phase = drawings.TextData(
-            data_type=types.LabelType.FRAME,
-            channels=data.inst[0].channel,
-            xvals=[data.t0],
-            yvals=[formatter["label_offset.frame_change"]],
-            text=f"VZ({plain_phase})",
-            latex=rf"{{\rm VZ}}({latex_phase})",
-            ignore_scaling=True,
-            styles=phase_style,
-        )
-        texts.append(phase)
-
-    # frequency value
-    if data.frame.freq != 0:
-        plain_freq, latex_freq = _freq_to_text(
-            formatter=formatter, freq=data.frame.freq, unit=_unit
-        )
-        freq_style = {"va": "center"}
-        freq_style.update(style)
-
-        freq = drawings.TextData(
-            data_type=types.LabelType.FRAME,
-            channels=data.inst[0].channel,
-            xvals=[data.t0],
-            yvals=[2 * formatter["label_offset.frame_change"]],
-            text=f"\u0394f = {plain_freq}",
-            latex=rf"\Delta f = {latex_freq}",
-            ignore_scaling=True,
-            styles=freq_style,
-        )
-        texts.append(freq)
-
-    return texts
-
-
-def gen_raw_operand_values_compact(
-    data: types.PulseInstruction, formatter: Dict[str, Any], device: device_info.DrawerBackendInfo
-) -> List[drawings.TextData]:
-    """Generate the formatted virtual Z rotation label and the frequency change label
-    from provided frame instruction.
-
-    Raw operand values are shown in compact form. Frequency change is expressed
-    in scientific notation. Values are shown in two lines.
-
-    For example:
-        - A phase change 1.57 and frequency change 1,234,567 are written by `1.57\\n1.2e+06`
-
-    Stylesheets:
-        - The `frame_change` style is applied.
-        - The `annotate` style is applied for font size.
-
-    Args:
-        data: Frame change instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-
-    style = {
-        "zorder": formatter["layer.frame_change"],
-        "color": formatter["color.frame_change"],
-        "size": formatter["text_size.annotate"],
-        "va": "center",
-        "ha": "center",
-    }
-
-    if data.frame.freq == 0:
-        freq_sci_notation = "0.0"
-    else:
-        abs_freq = np.abs(data.frame.freq)
-        base = data.frame.freq / (10 ** int(np.floor(np.log10(abs_freq))))
-        exponent = int(np.floor(np.log10(abs_freq)))
-        freq_sci_notation = f"{base:.1f}e{exponent:d}"
-    frame_info = f"{data.frame.phase:.2f}\n{freq_sci_notation}"
-
-    text = drawings.TextData(
-        data_type=types.LabelType.FRAME,
-        channels=data.inst[0].channel,
-        xvals=[data.t0],
-        yvals=[1.2 * formatter["label_offset.frame_change"]],
-        text=frame_info,
-        ignore_scaling=True,
-        styles=style,
-    )
-
-    return [text]
-
-
-def gen_frame_symbol(
-    data: types.PulseInstruction, formatter: Dict[str, Any], device: device_info.DrawerBackendInfo
-) -> List[drawings.TextData]:
-    """Generate a frame change symbol with instruction meta data from provided frame instruction.
-
-    Stylesheets:
-        - The `frame_change` style is applied.
-        - The symbol type in unicode is specified in `formatter.unicode_symbol.frame_change`.
-        - The symbol type in latex is specified in `formatter.latex_symbol.frame_change`.
-
-    Args:
-        data: Frame change instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    if data.frame.phase == 0 and data.frame.freq == 0:
-        return []
-
-    style = {
-        "zorder": formatter["layer.frame_change"],
-        "color": formatter["color.frame_change"],
-        "size": formatter["text_size.frame_change"],
-        "va": "center",
-        "ha": "center",
-    }
-
-    program = []
-    for inst in data.inst:
-        if isinstance(inst, (instructions.SetFrequency, instructions.ShiftFrequency)):
-            try:
-                program.append(f"{inst.__class__.__name__}({inst.frequency:.2e} Hz)")
-            except TypeError:
-                # parameter expression
-                program.append(f"{inst.__class__.__name__}({inst.frequency})")
-        elif isinstance(inst, (instructions.SetPhase, instructions.ShiftPhase)):
-            try:
-                program.append(f"{inst.__class__.__name__}({inst.phase:.2f} rad.)")
-            except TypeError:
-                # parameter expression
-                program.append(f"{inst.__class__.__name__}({inst.phase})")
-
-    meta = {
-        "total phase change": data.frame.phase,
-        "total frequency change": data.frame.freq,
-        "program": ", ".join(program),
-        "t0 (cycle time)": data.t0,
-        "t0 (sec)": data.t0 * data.dt if data.dt else "N/A",
-    }
-
-    text = drawings.TextData(
-        data_type=types.SymbolType.FRAME,
-        channels=data.inst[0].channel,
-        xvals=[data.t0],
-        yvals=[0],
-        text=formatter["unicode_symbol.frame_change"],
-        latex=formatter["latex_symbol.frame_change"],
-        ignore_scaling=True,
-        meta=meta,
-        styles=style,
-    )
-
-    return [text]
-
-
-def _phase_to_text(
-    formatter: Dict[str, Any], phase: float, max_denom: int = 10, flip: bool = True
-) -> Tuple[str, str]:
-    """A helper function to convert a float value to text with pi.
-
-    Args:
-        formatter: Dictionary of stylesheet settings.
-        phase: A phase value in units of rad.
-        max_denom: Maximum denominator. Return raw value if exceed.
-        flip: Set `True` to flip the sign.
-
-    Returns:
-        Standard text and latex text of phase value.
-    """
-    try:
-        phase = float(phase)
-    except TypeError:
-        # unbound parameter
-        return (
-            formatter["unicode_symbol.phase_parameter"],
-            formatter["latex_symbol.phase_parameter"],
-        )
-
-    frac = Fraction(np.abs(phase) / np.pi)
-
-    if phase == 0:
-        return "0", r"0"
-
-    num = frac.numerator
-    denom = frac.denominator
-    if denom > max_denom:
-        # denominator is too large
-        latex = rf"{np.abs(phase):.2f}"
-        plain = f"{np.abs(phase):.2f}"
-    else:
-        if num == 1:
-            if denom == 1:
-                latex = r"\pi"
-                plain = "pi"
-            else:
-                latex = rf"\pi/{denom:d}"
-                plain = f"pi/{denom:d}"
-        else:
-            latex = rf"{num:d}/{denom:d} \pi"
-            plain = f"{num:d}/{denom:d} pi"
-
-    if flip:
-        sign = "-" if phase > 0 else ""
-    else:
-        sign = "-" if phase < 0 else ""
-
-    return sign + plain, sign + latex
-
-
-def _freq_to_text(formatter: Dict[str, Any], freq: float, unit: str = "MHz") -> Tuple[str, str]:
-    """A helper function to convert a freq value to text with supplementary unit.
-
-    Args:
-        formatter: Dictionary of stylesheet settings.
-        freq: A frequency value in units of Hz.
-        unit: Supplementary unit. THz, GHz, MHz, kHz, Hz are supported.
-
-    Returns:
-        Standard text and latex text of phase value.
-
-    Raises:
-        VisualizationError: When unsupported unit is specified.
-    """
-    try:
-        freq = float(freq)
-    except TypeError:
-        # unbound parameter
-        return formatter["unicode_symbol.freq_parameter"], formatter["latex_symbol.freq_parameter"]
-
-    unit_table = {"THz": 1e12, "GHz": 1e9, "MHz": 1e6, "kHz": 1e3, "Hz": 1}
-
-    try:
-        value = freq / unit_table[unit]
-    except KeyError as ex:
-        raise VisualizationError(f"Unit {unit} is not supported.") from ex
-
-    latex = rf"{value:.2f}~{{\rm {unit}}}"
-    plain = f"{value:.2f} {unit}"
-
-    return plain, latex

qiskit/visualization/pulse_v2/generators/snapshot.py

@@ -1,133 +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.
-
-# pylint: disable=unused-argument
-
-"""Snapshot generators.
-
-A collection of functions that generate drawings from formatted input data.
-See py:mod:`qiskit.visualization.pulse_v2.types` for more info on the required data.
-
-In this module the input data is `types.SnapshotInstruction`.
-
-An end-user can write arbitrary functions that generate custom drawings.
-Generators in this module are called with the `formatter` and `device` kwargs.
-These data provides stylesheet configuration and backend system configuration.
-
-The format of generator is restricted to:
-
-    ```python
-
-    def my_object_generator(data: SnapshotInstruction,
-                            formatter: Dict[str, Any],
-                            device: DrawerBackendInfo) -> List[ElementaryData]:
-        pass
-    ```
-
-Arbitrary generator function satisfying the above format can be accepted.
-Returned `ElementaryData` can be arbitrary subclasses that are implemented in
-the plotter API.
-"""
-from typing import Dict, Any, List
-
-from qiskit.visualization.pulse_v2 import drawings, types, device_info
-
-
-def gen_snapshot_name(
-    data: types.SnapshotInstruction,
-    formatter: Dict[str, Any],
-    device: device_info.DrawerBackendInfo,
-) -> List[drawings.TextData]:
-    """Generate the name of snapshot.
-
-    Stylesheets:
-        - The `snapshot` style is applied for snapshot symbol.
-        - The `annotate` style is applied for label font size.
-
-    Args:
-        data: Snapshot instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    style = {
-        "zorder": formatter["layer.snapshot"],
-        "color": formatter["color.snapshot"],
-        "size": formatter["text_size.annotate"],
-        "va": "center",
-        "ha": "center",
-    }
-
-    text = drawings.TextData(
-        data_type=types.LabelType.SNAPSHOT,
-        channels=data.inst.channel,
-        xvals=[data.t0],
-        yvals=[formatter["label_offset.snapshot"]],
-        text=data.inst.name,
-        ignore_scaling=True,
-        styles=style,
-    )
-
-    return [text]
-
-
-def gen_snapshot_symbol(
-    data: types.SnapshotInstruction,
-    formatter: Dict[str, Any],
-    device: device_info.DrawerBackendInfo,
-) -> List[drawings.TextData]:
-    """Generate a snapshot symbol with instruction meta data from provided snapshot instruction.
-
-    Stylesheets:
-        - The `snapshot` style is applied for snapshot symbol.
-        - The symbol type in unicode is specified in `formatter.unicode_symbol.snapshot`.
-        - The symbol type in latex is specified in `formatter.latex_symbol.snapshot`.
-
-    Args:
-        data: Snapshot instruction data to draw.
-        formatter: Dictionary of stylesheet settings.
-        device: Backend configuration.
-
-    Returns:
-        List of `TextData` drawings.
-    """
-    style = {
-        "zorder": formatter["layer.snapshot"],
-        "color": formatter["color.snapshot"],
-        "size": formatter["text_size.snapshot"],
-        "va": "bottom",
-        "ha": "center",
-    }
-
-    meta = {
-        "snapshot type": data.inst.type,
-        "t0 (cycle time)": data.t0,
-        "t0 (sec)": data.t0 * data.dt if data.dt else "N/A",
-        "name": data.inst.name,
-        "label": data.inst.label,
-    }
-
-    text = drawings.TextData(
-        data_type=types.SymbolType.SNAPSHOT,
-        channels=data.inst.channel,
-        xvals=[data.t0],
-        yvals=[0],
-        text=formatter["unicode_symbol.snapshot"],
-        latex=formatter["latex_symbol.snapshot"],
-        ignore_scaling=True,
-        meta=meta,
-        styles=style,
-    )
-
-    return [text]