From 2ca1fad4708a0a04e74dad5d72ac47b0050be871 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Sun, 24 Oct 2021 21:48:31 +0200 Subject: [PATCH 01/18] * Moved Rabi to characterization. --- .../calibration_management/update_library.py | 2 +- qiskit_experiments/library/__init__.py | 8 ++++---- qiskit_experiments/library/calibration/__init__.py | 2 -- qiskit_experiments/library/characterization/__init__.py | 3 +++ .../library/{calibration => characterization}/rabi.py | 0 5 files changed, 8 insertions(+), 7 deletions(-) rename qiskit_experiments/library/{calibration => characterization}/rabi.py (100%) diff --git a/qiskit_experiments/calibration_management/update_library.py b/qiskit_experiments/calibration_management/update_library.py index 57a177aba8..6db3ba40d5 100644 --- a/qiskit_experiments/calibration_management/update_library.py +++ b/qiskit_experiments/calibration_management/update_library.py @@ -280,7 +280,7 @@ def update( Raises: CalibrationError: If the experiment is not of the supported type. """ - from qiskit_experiments.library.calibration.rabi import Rabi + from qiskit_experiments.library.characterization.rabi import Rabi if angles_schedules is None: angles_schedules = [(np.pi, "amp", "xp")] diff --git a/qiskit_experiments/library/__init__.py b/qiskit_experiments/library/__init__.py index c0767f31a9..b36bfdb1fa 100644 --- a/qiskit_experiments/library/__init__.py +++ b/qiskit_experiments/library/__init__.py @@ -65,6 +65,8 @@ ~characterization.FineAmplitude ~characterization.FineXAmplitude ~characterization.FineSXAmplitude + ~characterization.Rabi + ~characterization.EFRabi .. _calibration: @@ -86,8 +88,6 @@ class instance to manage parameters and pulse schedules. ~calibration.FineDrag ~calibration.FineXDrag ~calibration.FineSXDrag - ~calibration.Rabi - ~calibration.EFRabi ~calibration.FineAmplitudeCal ~calibration.FineXAmplitudeCal ~calibration.FineSXAmplitudeCal @@ -99,8 +99,6 @@ class instance to manage parameters and pulse schedules. FineDrag, FineXDrag, FineSXDrag, - Rabi, - EFRabi, FineAmplitudeCal, FineXAmplitudeCal, FineSXAmplitudeCal, @@ -114,6 +112,8 @@ class instance to manage parameters and pulse schedules. EFSpectroscopy, CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian, + Rabi, + EFRabi, FineAmplitude, FineXAmplitude, FineSXAmplitude, diff --git a/qiskit_experiments/library/calibration/__init__.py b/qiskit_experiments/library/calibration/__init__.py index 139c575207..da4fa46302 100644 --- a/qiskit_experiments/library/calibration/__init__.py +++ b/qiskit_experiments/library/calibration/__init__.py @@ -44,7 +44,6 @@ FineDrag FineXDrag FineSXDrag - Rabi FineAmplitudeCal FineXAmplitudeCal FineSXAmplitudeCal @@ -71,7 +70,6 @@ from .drag import DragCal from .fine_drag import FineDrag, FineXDrag, FineSXDrag from .fine_amplitude import FineAmplitudeCal, FineXAmplitudeCal, FineSXAmplitudeCal -from .rabi import Rabi, EFRabi from .ramsey_xy import RamseyXY from .analysis.drag_analysis import DragCalAnalysis diff --git a/qiskit_experiments/library/characterization/__init__.py b/qiskit_experiments/library/characterization/__init__.py index 25e2f473d9..f582129d23 100644 --- a/qiskit_experiments/library/characterization/__init__.py +++ b/qiskit_experiments/library/characterization/__init__.py @@ -28,6 +28,8 @@ QubitSpectroscopy CrossResonanceHamiltonian EchoedCrossResonanceHamiltonian + Rabi + EFRabi FineAmplitude FineXAmplitude FineSXAmplitude @@ -54,4 +56,5 @@ from .t2ramsey_analysis import T2RamseyAnalysis from .cr_hamiltonian import CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis +from .rabi import Rabi, EFRabi from .fine_amplitude import FineAmplitude, FineXAmplitude, FineSXAmplitude diff --git a/qiskit_experiments/library/calibration/rabi.py b/qiskit_experiments/library/characterization/rabi.py similarity index 100% rename from qiskit_experiments/library/calibration/rabi.py rename to qiskit_experiments/library/characterization/rabi.py From 9b4e564990f19ac43fff96b9d261ea0f34dad58e Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Tue, 26 Oct 2021 16:53:19 +0200 Subject: [PATCH 02/18] * Refactor EFRabi and tests accordingly. * Added tests for rough amp calibration. * Reworked init files and docs in them. * Added rough amplitude cal. * Moved mock rabi backend. * Removed amplitude update from updates. --- .../calibration_management/__init__.py | 3 +- .../calibration_management/update_library.py | 53 ----- qiskit_experiments/library/__init__.py | 6 + .../library/calibration/__init__.py | 4 + .../calibration/rough_amplitude_cal.py | 206 ++++++++++++++++++ .../library/characterization/rabi.py | 181 +++++---------- qiskit_experiments/test/mock_iq_backend.py | 25 +++ test/calibration/experiments/test_rabi.py | 92 ++++---- .../experiments/test_rough_amplitude.py | 132 +++++++++++ 9 files changed, 479 insertions(+), 223 deletions(-) create mode 100644 qiskit_experiments/library/calibration/rough_amplitude_cal.py create mode 100644 test/calibration/experiments/test_rough_amplitude.py diff --git a/qiskit_experiments/calibration_management/__init__.py b/qiskit_experiments/calibration_management/__init__.py index 6a41faeb59..0a5f6ed86e 100644 --- a/qiskit_experiments/calibration_management/__init__.py +++ b/qiskit_experiments/calibration_management/__init__.py @@ -39,7 +39,6 @@ BackendCalibrations Calibrations Frequency - Amplitude Drag Managing Calibration Data @@ -150,4 +149,4 @@ from .backend_calibrations import BackendCalibrations from .base_calibration_experiment import BaseCalibrationExperiment -from .update_library import Frequency, Drag, Amplitude, FineDragUpdater +from .update_library import Frequency, Drag, FineDragUpdater diff --git a/qiskit_experiments/calibration_management/update_library.py b/qiskit_experiments/calibration_management/update_library.py index 6db3ba40d5..007ada1fec 100644 --- a/qiskit_experiments/calibration_management/update_library.py +++ b/qiskit_experiments/calibration_management/update_library.py @@ -245,56 +245,3 @@ def update( new_beta = old_beta + d_beta cls.add_parameter_value(calibrations, exp_data, new_beta, parameter, schedule, group) - - -class Amplitude(BaseUpdater): - """Update pulse amplitudes.""" - - # pylint: disable=arguments-differ,unused-argument - @classmethod - def update( - cls, - calibrations: Calibrations, - exp_data: ExperimentData, - result_index: Optional[int] = -1, - group: str = "default", - angles_schedules: List[Tuple[float, str, Union[str, ScheduleBlock]]] = None, - **options, - ): - """Update the amplitude of pulses. - - The value of the amplitude must be derived from the fit so the base method cannot be used. - - Args: - calibrations: The calibrations to update. - exp_data: The experiment data from which to update. - result_index: The result index to use which defaults to -1. - group: The calibrations group to update. Defaults to "default." - angles_schedules: A list of tuples specifying which angle to update for which - pulse schedule. Each tuple is of the form: (angle, parameter_name, - schedule). Here, angle is the rotation angle for which to extract the amplitude, - parameter_name is the name of the parameter whose value is to be updated, and - schedule is the schedule or its name that contains the parameter. - options: Trailing options. - - Raises: - CalibrationError: If the experiment is not of the supported type. - """ - from qiskit_experiments.library.characterization.rabi import Rabi - - if angles_schedules is None: - angles_schedules = [(np.pi, "amp", "xp")] - - if isinstance(exp_data.experiment, Rabi): - rate = 2 * np.pi * BaseUpdater.get_value(exp_data, "rabi_rate", result_index) - - for angle, param, schedule in angles_schedules: - qubits = exp_data.metadata["physical_qubits"] - prev_amp = calibrations.get_parameter_value(param, qubits, schedule, group=group) - - value = np.round(angle / rate, decimals=8) * np.exp(1.0j * np.angle(prev_amp)) - - cls.add_parameter_value(calibrations, exp_data, value, param, schedule, group) - - else: - raise CalibrationError(f"{cls.__name__} updates from {type(Rabi.__name__)}.") diff --git a/qiskit_experiments/library/__init__.py b/qiskit_experiments/library/__init__.py index b36bfdb1fa..35517e7cee 100644 --- a/qiskit_experiments/library/__init__.py +++ b/qiskit_experiments/library/__init__.py @@ -92,6 +92,9 @@ class instance to manage parameters and pulse schedules. ~calibration.FineXAmplitudeCal ~calibration.FineSXAmplitudeCal ~calibration.RamseyXY + ~calibration.RoughAmplitudeCal + ~calibration.RoughXSXAmplitudeCal + ~calibration.EFRoughXSXAmplitudeCal """ from .calibration import ( @@ -99,6 +102,9 @@ class instance to manage parameters and pulse schedules. FineDrag, FineXDrag, FineSXDrag, + RoughAmplitudeCal, + RoughXSXAmplitudeCal, + EFRoughXSXAmplitudeCal, FineAmplitudeCal, FineXAmplitudeCal, FineSXAmplitudeCal, diff --git a/qiskit_experiments/library/calibration/__init__.py b/qiskit_experiments/library/calibration/__init__.py index da4fa46302..fdc52b110a 100644 --- a/qiskit_experiments/library/calibration/__init__.py +++ b/qiskit_experiments/library/calibration/__init__.py @@ -48,6 +48,9 @@ FineXAmplitudeCal FineSXAmplitudeCal RamseyXY + RoughAmplitudeCal + RoughXSXAmplitudeCal + EFRoughXSXAmplitudeCal Calibration analysis ==================== @@ -69,6 +72,7 @@ from .rough_frequency import RoughFrequencyCal from .drag import DragCal from .fine_drag import FineDrag, FineXDrag, FineSXDrag +from .rough_amplitude_cal import RoughAmplitudeCal, RoughXSXAmplitudeCal, EFRoughXSXAmplitudeCal from .fine_amplitude import FineAmplitudeCal, FineXAmplitudeCal, FineSXAmplitudeCal from .ramsey_xy import RamseyXY diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py new file mode 100644 index 0000000000..26a9daf9cb --- /dev/null +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -0,0 +1,206 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# 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. + +"""Rough amplitude calibration using Rabi.""" + +from typing import Iterable, List, Optional +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.circuit import Parameter + +from qiskit_experiments.framework import ExperimentData +from qiskit_experiments.calibration_management import BaseCalibrationExperiment, BackendCalibrations +from qiskit_experiments.library.characterization import Rabi +from qiskit_experiments.calibration_management.update_library import BaseUpdater + + +class RoughAmplitudeCal(BaseCalibrationExperiment, Rabi): + """A calibration version of the Rabi experiment.""" + + def __init__( + self, + qubit: int, + calibrations: BackendCalibrations, + schedule_name: str = "x", + amplitudes: Iterable[float] = None, + cal_parameter_name: Optional[str] = "amp", + target_angle: float = np.pi, + auto_update: bool = True, + group: str = "default", + ): + """see class :class:`Rabi` for details. + + Args: + qubit: The qubit for which to run the rough amplitude calibration. + calibrations: The calibrations instance with the schedules. + schedule_name: The name of the schedule to calibrate. + cal_parameter_name: The name of the parameter in the schedule to update. + auto_update: Whether or not to automatically update the calibrations. By + default this variable is set to True. + group: The group of calibration parameters to use. The default value is "default". + """ + schedule = calibrations.get_schedule( + schedule_name, qubit, assign_params={cal_parameter_name: Parameter("amp")}, group=group + ) + + super().__init__( + calibrations, + qubit, + schedule=schedule, + amplitudes=amplitudes, + schedule_name=schedule_name, + cal_parameter_name=cal_parameter_name, + auto_update=auto_update, + ) + + # Needed for subclasses that will drive other transitions than the 0<->1 transition. + self.transpile_options.inst_map = calibrations.default_inst_map + + # Set the pulses to update. + self.experiment_options.group = group + self.experiment_options.angles_schedules = [ + (target_angle, cal_parameter_name, schedule_name) + ] + + @classmethod + def _default_experiment_options(cls): + """Default values for the fine amplitude calibration experiment. + + Experiment Options: + result_index (int): The index of the result from which to update the calibrations. + angles_schedules List(float, str, str, float): A list of parameter update information. + Each entry of the list is a tuple with four entries: the target angle of the + rotation, the name of the amplitude parameter to update, the name of the schedule + containing the amplitude parameter to update, and the previous value of the + amplitude parameter to update. + group (str): The calibration group to which the parameter belongs. This will default + to the value "default". + """ + options = super()._default_experiment_options() + + options.result_index = -1 + options.angles_schedules = [(np.pi, "amp", "x", None)] + options.group = "default" + + return options + + def _add_cal_metadata(self, circuits: List[QuantumCircuit]): + """Add metadata to the circuit to make the experiment data more self contained. + + The following keys are added to each circuit's metadata: + angles_schedules: A list of parameter update information. Each entry of the list + is a tuple with four entries: the target angle of the rotation, the name of the + amplitude parameter to update, the name of the schedule containing the amplitude + parameter to update, and the previous value of the amplitude parameter to update. + cal_group: The calibration group to which the amplitude parameters belong. + """ + + param_values = [] + for angle, param_name, schedule_name in self.experiment_options.angles_schedules: + param_val = self._cals.get_parameter_value( + param_name, + self._physical_qubits, + schedule_name, + group=self.experiment_options.group, + ) + + param_values.append((angle, param_name, schedule_name, param_val)) + + for circuit in circuits: + circuit.metadata["angles_schedules"] = param_values + circuit.metadata["cal_group"] = self.experiment_options.group + + return circuits + + def update_calibrations(self, experiment_data: ExperimentData): + r"""Update the amplitude of one or several pulses. + + The update rule extracts the rate of the oscillation from the fit to the cosine function. + Recall that the amplitude is the x-axis in the analysis of the :class:`Rabi` experiment. + The value of the amplitude is thus the desired rotation-angle divided by the rate of + the oscillation: + + .. math:: + + A_i \to \frac{\theta_i}{\omega} + + where :math:`\theta_i` is the desired rotation angle (e.g. :math:`\pi` and :math:`\pi/2` + for "x" and "sx" gates, respectively) and :math:`\omega` is the rate of the oscillation. + + Args: + experiment_data: The experiment data from which to extract the measured over/under + rotation used to adjust the amplitude. + """ + + data = experiment_data.data() + + # No data -> no update + if len(data) > 0: + result_index = self.experiment_options.result_index + group = data[0]["metadata"]["cal_group"] + + rate = 2 * np.pi * BaseUpdater.get_value(experiment_data, "rabi_rate", result_index) + + for angle, param, schedule, prev_amp in data[0]["metadata"]["angles_schedules"]: + + value = np.round(angle / rate, decimals=8) * np.exp(1.0j * np.angle(prev_amp)) + + BaseUpdater.add_parameter_value( + self._cals, experiment_data, value, param, schedule, group + ) + + +class RoughXSXAmplitudeCal(RoughAmplitudeCal): + """A rough amplitude calibration of x and sx gates.""" + + def __init__( + self, qubit: int, calibrations: BackendCalibrations, amplitudes: Iterable[float] = None + ): + """A rough amplitude calibration that updates both the sx and x pulses.""" + super().__init__(qubit, calibrations, "x", amplitudes, "amp", np.pi) + + self.experiment_options.angles_schedules = [(np.pi, "amp", "x"), (np.pi / 2, "amp", "sx")] + + +class EFRoughXSXAmplitudeCal(RoughAmplitudeCal): + """A rough amplitude calibration of x and sx gates on the 1<->2 transition.""" + + def __init__( + self, + qubit: int, + calibrations: BackendCalibrations, + amplitudes: Iterable[float] = None, + ef_pulse_label: str = "12", + ): + r"""A rough amplitude calibration that updates both the sx and x pulses on 1<->2. + + Args: + qubit: The index of the qubit (technically a qutrit) to run on. + calibrations: The calibrations instance that stores the pulse schedules. + amplitudes: The amplitudes to scan. + ef_pulse_label: A label that is post-pended to "x" and "sx" to obtain the name + of the pulses that drive a :math:`\pi` and :math:`\pi/2` rotation on + the 1<->2 transition. + """ + super().__init__(qubit, calibrations, "x" + ef_pulse_label, amplitudes, "amp", np.pi) + + self.experiment_options.angles_schedules = [ + (np.pi, "amp", "x" + ef_pulse_label), + (np.pi / 2, "amp", "sx" + ef_pulse_label), + ] + + def _pre_circuit(self) -> QuantumCircuit: + """A circuit with operations to perform before the Rabi.""" + circ = QuantumCircuit(1) + circ.x(0) + return circ diff --git a/qiskit_experiments/library/characterization/rabi.py b/qiskit_experiments/library/characterization/rabi.py index a85998ae1c..7a0955334d 100644 --- a/qiskit_experiments/library/characterization/rabi.py +++ b/qiskit_experiments/library/characterization/rabi.py @@ -12,26 +12,26 @@ """Rabi amplitude experiment.""" -from typing import List, Optional +from typing import Iterable, List, Optional, Tuple import numpy as np from qiskit import QuantumCircuit from qiskit.circuit import Gate, Parameter from qiskit.qobj.utils import MeasLevel from qiskit.providers import Backend -import qiskit.pulse as pulse +from qiskit.pulse import ScheduleBlock +from qiskit.exceptions import QiskitError from qiskit_experiments.framework import BaseExperiment, Options from qiskit_experiments.curve_analysis import ParameterRepr, OscillationAnalysis -from qiskit_experiments.exceptions import CalibrationError class Rabi(BaseExperiment): - """An experiment that scans the amplitude of a pulse to calibrate rotations between 0 and 1. + """An experiment that scans a pulse amplitude to calibrate rotations between 0 and 1. # section: overview - The circuits that are run have a custom rabi gate with the pulse schedule attached to it + The circuits have a custom rabi gate with the pulse schedule attached to it through the calibrations. The circuits are of the form: .. parsed-literal:: @@ -42,8 +42,8 @@ class Rabi(BaseExperiment): measure: 1/═════════════════╩═ 0 - If the user provides his own schedule for the Rabi then it must have one free parameter, - i.e. the amplitude that will be scanned, and a drive channel which matches the qubit. + The user provides his own schedule for the Rabi at initialization which must have one + free parameter, i.e. the amplitude to scan and a drive channel which matches the qubit. # section: tutorial :doc:`/tutorials/calibrating_armonk` @@ -55,7 +55,7 @@ class Rabi(BaseExperiment): """ __analysis_class__ = OscillationAnalysis - __rabi_gate_name__ = "Rabi" + __gate_name__ = "Rabi" @classmethod def _default_run_options(cls) -> Options: @@ -78,16 +78,13 @@ def _default_experiment_options(cls) -> Options: rabi.set_experiment_options(schedule=rabi_schedule) Experiment Options: - duration (int): The duration of the default Gaussian pulse. - sigma (float): The standard deviation of the default Gaussian pulse. amplitudes (iterable): The list of amplitude values to scan. - schedule (ScheduleBlock): The schedule for the Rabi pulse that overrides the default. + schedule (ScheduleBlock): The schedule for the Rabi pulse. This schedule must have + exactly one free parameter. The drive channel should match the qubit. """ options = super()._default_experiment_options() - options.duration = 160 - options.sigma = 40 options.amplitudes = np.linspace(-0.95, 0.95, 51) options.schedule = None @@ -104,45 +101,48 @@ def _default_analysis_options(cls) -> Options: return options - def __init__(self, qubit: int): + def __init__( + self, qubit: int, schedule: ScheduleBlock, amplitudes: Optional[Iterable[float]] = None + ): """Initialize a Rabi experiment on the given qubit. - The parameters of the Gaussian Rabi pulse can be specified at run-time. - The rabi pulse has the following parameters: - - duration: The duration of the rabi pulse in samples, the default is 160 samples. - - sigma: The standard deviation of the pulse, the default is duration 40. - - amplitudes: The amplitude that are scanned in the experiment, default is - np.linspace(-0.95, 0.95, 51) - Args: qubit: The qubit on which to run the Rabi experiment. + schedule: The schedule that will be used in the Rabi experiment. This schedule + should have one free parameter namely the amplitude. + amplitudes: The pulse amplitudes that one wishes to scan. If this variable is not + specified it will default to :code:`np.linspace(-0.95, 0.95, 51)`. """ super().__init__([qubit]) - def _template_circuit(self, amp_param) -> QuantumCircuit: + if amplitudes is not None: + self.experiment_options.amplitudes = amplitudes + + self.experiment_options.schedule = schedule + + def _pre_circuit(self) -> QuantumCircuit: + """A circuit with operations to perform before the Rabi.""" + return QuantumCircuit(1) + + def _template_circuit(self) -> Tuple[QuantumCircuit, Parameter]: """Return the template quantum circuit.""" - gate = Gate(name=self.__rabi_gate_name__, num_qubits=1, params=[amp_param]) + sched = self.experiment_options.schedule + param = next(iter(sched.parameters)) + + if len(sched.parameters) != 1: + raise QiskitError( + f"Schedule {sched} for {self.__class__.__name__} experiment must have " + f"exactly one free parameter, found {sched.parameters} parameters." + ) + + gate = Gate(name=self.__gate_name__, num_qubits=1, params=[param]) - circuit = QuantumCircuit(1) + circuit = self._pre_circuit() circuit.append(gate, (0,)) circuit.measure_active() + circuit.add_calibration(gate, self._physical_qubits, sched, params=[param]) - return circuit - - def _default_gate_schedule(self, backend: Optional[Backend] = None): - """Create the default schedule for the Rabi gate.""" - amp = Parameter("amp") - with pulse.build(backend=backend, name="rabi") as default_schedule: - pulse.play( - pulse.Gaussian( - duration=self.experiment_options.duration, - amp=amp, - sigma=self.experiment_options.sigma, - ), - pulse.DriveChannel(self.physical_qubits[0]), - ) - - return default_schedule + return circuit, param def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: """Create the circuits for the Rabi experiment. @@ -160,27 +160,9 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: that matches the qubit on which to run the Rabi experiment. - If the user provided schedule has more than one free parameter. """ - schedule = self.experiment_options.get("schedule", None) - - if schedule is None: - schedule = self._default_gate_schedule(backend=backend) - else: - if self.physical_qubits[0] not in set(ch.index for ch in schedule.channels): - raise CalibrationError( - f"User provided schedule {schedule.name} does not contain a channel " - "for the qubit on which to run Rabi." - ) - - if len(schedule.parameters) != 1: - raise CalibrationError("Schedule in Rabi must have exactly one free parameter.") - - param = next(iter(schedule.parameters)) # Create template circuit - circuit = self._template_circuit(param) - circuit.add_calibration( - self.__rabi_gate_name__, (self.physical_qubits[0],), schedule, params=[param] - ) + circuit, param = self._template_circuit() # Create the circuits to run circs = [] @@ -189,11 +171,10 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: assigned_circ = circuit.assign_parameters({param: amp}, inplace=False) assigned_circ.metadata = { "experiment_type": self._type, - "qubits": (self.physical_qubits[0],), + "qubits": self.physical_qubits, "xval": amp, "unit": "arb. unit", "amplitude": amp, - "schedule": str(schedule), } if backend: @@ -210,13 +191,11 @@ class EFRabi(Rabi): # section: overview This experiment is a subclass of the :class:`Rabi` experiment but takes place between - the first and second excited state. An initial X gate used to populate the first excited - state. The Rabi pulse is then applied on the 1 <-> 2 transition (sometimes also labeled - the e <-> f transition) which implies that frequency shift instructions are used. The - necessary frequency shift (typically the qubit anharmonicity) should be specified - through the experiment options. - - The circuits are of the form: + the first and second excited state. An initial X gate populates the first excited state. + The Rabi pulse is applied on the 1 <-> 2 transition (sometimes also labeled the e <-> f + transition). The necessary frequency shift (typically the qubit anharmonicity) is given + through the pulse schedule given at initialization. The schedule is then also stored in + the experiment options. The circuits are of the form: .. parsed-literal:: @@ -235,20 +214,6 @@ class EFRabi(Rabi): """ - @classmethod - def _default_experiment_options(cls) -> Options: - """Default values for the pulse if no schedule is given. - - Experiment Options: - - frequency_shift (float): The frequency by which the 1 to 2 transition is - detuned from the 0 to 1 transition. - """ - options = super()._default_experiment_options() - options.frequency_shift = None - - return options - @classmethod def _default_analysis_options(cls) -> Options: """Default analysis options.""" @@ -257,50 +222,8 @@ def _default_analysis_options(cls) -> Options: return options - def _default_gate_schedule(self, backend: Optional[Backend] = None): - """Create the default schedule for the EFRabi gate with a frequency shift to the 1-2 - transition.""" - - if self.experiment_options.frequency_shift is None: - try: - anharm, _ = backend.properties().qubit_property(self.physical_qubits[0])[ - "anharmonicity" - ] - self.set_experiment_options(frequency_shift=anharm) - except KeyError as key_err: - raise CalibrationError( - f"The backend {backend} does not provide an anharmonicity for qubit " - f"{self.physical_qubits[0]}. Use EFRabi.set_experiment_options(frequency_shift=" - f"anharmonicity) to manually set the correct frequency for the 1-2 transition." - ) from key_err - except AttributeError as att_err: - raise CalibrationError( - "When creating the default schedule without passing a backend, the frequency needs " - "to be set manually through EFRabi.set_experiment_options(frequency_shift=..)." - ) from att_err - - amp = Parameter("amp") - with pulse.build(backend=backend, name=self.__rabi_gate_name__) as default_schedule: - with pulse.frequency_offset( - self.experiment_options.frequency_shift, - pulse.DriveChannel(self.physical_qubits[0]), - ): - pulse.play( - pulse.Gaussian( - duration=self.experiment_options.duration, - amp=amp, - sigma=self.experiment_options.sigma, - ), - pulse.DriveChannel(self.physical_qubits[0]), - ) - - return default_schedule - - def _template_circuit(self, amp_param) -> QuantumCircuit: - """Return the template quantum circuit.""" - circuit = QuantumCircuit(1) - circuit.x(0) - circuit.append(Gate(name=self.__rabi_gate_name__, num_qubits=1, params=[amp_param]), (0,)) - circuit.measure_active() - - return circuit + def _pre_circuit(self) -> QuantumCircuit: + """A circuit with operations to perform before the Rabi.""" + circ = QuantumCircuit(1) + circ.x(0) + return circ diff --git a/qiskit_experiments/test/mock_iq_backend.py b/qiskit_experiments/test/mock_iq_backend.py index c142880a42..606f4d4dc2 100644 --- a/qiskit_experiments/test/mock_iq_backend.py +++ b/qiskit_experiments/test/mock_iq_backend.py @@ -156,6 +156,31 @@ def _compute_probability(self, circuit: QuantumCircuit) -> float: return np.sin(n_gates * self._error * (beta - self.ideal_beta)) ** 2 +class RabiBackend(MockIQBackend): + """A simple and primitive backend, to be run by the Rabi tests.""" + + def __init__( + self, + iq_cluster_centers: Tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0), + iq_cluster_width: float = 1.0, + amplitude_to_angle: float = np.pi, + ): + """Initialize the rabi backend.""" + self._amplitude_to_angle = amplitude_to_angle + + super().__init__(iq_cluster_centers, iq_cluster_width) + + @property + def rabi_rate(self) -> float: + """Returns the rabi rate.""" + return self._amplitude_to_angle / np.pi + + def _compute_probability(self, circuit: QuantumCircuit) -> float: + """Returns the probability based on the rotation angle and amplitude_to_angle.""" + amp = next(iter(circuit.calibrations["Rabi"].keys()))[1][0] + return np.sin(self._amplitude_to_angle * amp) ** 2 + + class MockFineAmp(MockIQBackend): """A mock backend for fine amplitude calibration.""" diff --git a/test/calibration/experiments/test_rabi.py b/test/calibration/experiments/test_rabi.py index 0e1d6ad51e..d97f13332b 100644 --- a/test/calibration/experiments/test_rabi.py +++ b/test/calibration/experiments/test_rabi.py @@ -12,7 +12,6 @@ """Test Rabi amplitude Experiment class.""" -from typing import Tuple import numpy as np from qiskit import QuantumCircuit, transpile @@ -29,36 +28,22 @@ from qiskit_experiments.curve_analysis.standard_analysis.oscillation import OscillationAnalysis from qiskit_experiments.data_processing.data_processor import DataProcessor from qiskit_experiments.data_processing.nodes import Probability -from qiskit_experiments.test.mock_iq_backend import MockIQBackend +from qiskit_experiments.test.mock_iq_backend import RabiBackend -class RabiBackend(MockIQBackend): - """A simple and primitive backend, to be run by the Rabi tests.""" - - def __init__( - self, - iq_cluster_centers: Tuple[float, float, float, float] = (1.0, 1.0, -1.0, -1.0), - iq_cluster_width: float = 1.0, - amplitude_to_angle: float = np.pi, - ): - """Initialize the rabi backend.""" - self._amplitude_to_angle = amplitude_to_angle +class TestRabiEndToEnd(QiskitTestCase): + """Test the rabi experiment.""" - super().__init__(iq_cluster_centers, iq_cluster_width) + def setUp(self): + """Setup the tests.""" + super().setUp() - @property - def rabi_rate(self) -> float: - """Returns the rabi rate.""" - return self._amplitude_to_angle / np.pi + self.qubit = 1 - def _compute_probability(self, circuit: QuantumCircuit) -> float: - """Returns the probability based on the rotation angle and amplitude_to_angle.""" - amp = next(iter(circuit.calibrations["Rabi"].keys()))[1][0] - return np.sin(self._amplitude_to_angle * amp) ** 2 + with pulse.build(name="x") as sched: + pulse.play(pulse.Drag(160, Parameter("amp"), 40, 0.4), pulse.DriveChannel(self.qubit)) - -class TestRabiEndToEnd(QiskitTestCase): - """Test the rabi experiment.""" + self.sched = sched def test_rabi_end_to_end(self): """Test the Rabi experiment end to end.""" @@ -66,7 +51,7 @@ def test_rabi_end_to_end(self): test_tol = 0.01 backend = RabiBackend() - rabi = Rabi(1) + rabi = Rabi(self.qubit, self.sched) rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 21)) expdata = rabi.run(backend) expdata.block_for_results() @@ -77,7 +62,7 @@ def test_rabi_end_to_end(self): backend = RabiBackend(amplitude_to_angle=np.pi / 2) - rabi = Rabi(1) + rabi = Rabi(self.qubit, self.sched) rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 21)) expdata = rabi.run(backend) expdata.block_for_results() @@ -87,7 +72,7 @@ def test_rabi_end_to_end(self): backend = RabiBackend(amplitude_to_angle=2.5 * np.pi) - rabi = Rabi(1) + rabi = Rabi(self.qubit, self.sched) rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 101)) expdata = rabi.run(backend) expdata.block_for_results() @@ -100,7 +85,7 @@ def test_wrong_processor(self): backend = RabiBackend() - rabi = Rabi(1) + rabi = Rabi(self.qubit, self.sched) fail_key = "fail_key" @@ -116,18 +101,31 @@ def test_wrong_processor(self): class TestEFRabi(QiskitTestCase): """Test the ef_rabi experiment.""" + def setUp(self): + """Setup the tests.""" + super().setUp() + + self.qubit = 0 + + with pulse.build(name="x") as sched: + with pulse.frequency_offset(-300e6, pulse.DriveChannel(self.qubit)): + pulse.play( + pulse.Drag(160, Parameter("amp"), 40, 0.4), + pulse.DriveChannel(self.qubit) + ) + + self.sched = sched + def test_ef_rabi_end_to_end(self): """Test the EFRabi experiment end to end.""" test_tol = 0.01 backend = RabiBackend() - qubit = 0 # Note that the backend is not sophisticated enough to simulate an e-f # transition so we run the test with a tiny frequency shift, still driving the e-g transition. freq_shift = 0.01 - rabi = EFRabi(qubit) - rabi.set_experiment_options(frequency_shift=freq_shift) + rabi = EFRabi(self.qubit, self.sched) rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 21)) expdata = rabi.run(backend) expdata.block_for_results() @@ -139,8 +137,14 @@ def test_ef_rabi_end_to_end(self): def test_ef_rabi_circuit(self): """Test the EFRabi experiment end to end.""" anharm = -330e6 - rabi12 = EFRabi(2) - rabi12.set_experiment_options(amplitudes=[0.5], frequency_shift=anharm) + + with pulse.build() as sched: + pulse.shift_frequency(anharm, pulse.DriveChannel(2)) + pulse.play(pulse.Gaussian(160, Parameter("amp"), 40), pulse.DriveChannel(2)) + pulse.shift_frequency(-anharm, pulse.DriveChannel(2)) + + rabi12 = EFRabi(2, sched) + rabi12.set_experiment_options(amplitudes=[0.5]) circ = rabi12.circuits(RabiBackend())[0] with pulse.build() as expected: @@ -156,10 +160,19 @@ def test_ef_rabi_circuit(self): class TestRabiCircuits(QiskitTestCase): """Test the circuits generated by the experiment and the options.""" + def setUp(self): + """Setup tests.""" + super().setUp() + + with pulse.build() as sched: + pulse.play(pulse.Gaussian(160, Parameter("amp"), 40), pulse.DriveChannel(2)) + + self.sched = sched + def test_default_schedule(self): """Test the default schedule.""" - rabi = Rabi(2) + rabi = Rabi(2, self.sched) rabi.set_experiment_options(amplitudes=[0.5]) circs = rabi.circuits(RabiBackend()) @@ -177,7 +190,7 @@ def test_user_schedule(self): pulse.play(pulse.Drag(160, amp, 40, 10), pulse.DriveChannel(2)) pulse.play(pulse.Drag(160, amp, 40, 10), pulse.DriveChannel(2)) - rabi = Rabi(2) + rabi = Rabi(2, self.sched) rabi.set_experiment_options(schedule=my_schedule, amplitudes=[0.5]) circs = rabi.circuits(RabiBackend()) @@ -269,9 +282,10 @@ def test_calibrations(self): experiments = [] for qubit in range(3): - rabi = Rabi(qubit) - rabi.set_experiment_options(amplitudes=[0.5]) - experiments.append(rabi) + with pulse.build() as sched: + pulse.play(pulse.Gaussian(160, Parameter("amp"), 40), pulse.DriveChannel(qubit)) + + experiments.append(Rabi(qubit, sched, amplitudes=[0.5])) par_exp = ParallelExperiment(experiments) par_circ = par_exp.circuits()[0] diff --git a/test/calibration/experiments/test_rough_amplitude.py b/test/calibration/experiments/test_rough_amplitude.py new file mode 100644 index 0000000000..c4d6558f1c --- /dev/null +++ b/test/calibration/experiments/test_rough_amplitude.py @@ -0,0 +1,132 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# 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. + +"""Test rough amplitude calibration experiment classes.""" + +import numpy as np + +from qiskit import transpile +import qiskit.pulse as pulse +from qiskit.circuit import Parameter +from qiskit.test import QiskitTestCase +from qiskit.test.mock import FakeArmonk + +from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon +from qiskit_experiments.calibration_management import BackendCalibrations +from qiskit_experiments.library import EFRoughXSXAmplitudeCal, RoughXSXAmplitudeCal +from qiskit_experiments.test.mock_iq_backend import RabiBackend + + +class TestRoughAmpCal(QiskitTestCase): + """A class to test the rough amplitude calibration experiments.""" + + def setUp(self): + """Setup the tests.""" + super().setUp() + library = FixedFrequencyTransmon() + + self.backend = FakeArmonk() + self.cals = BackendCalibrations(self.backend, library) + + def test_circuits(self): + """Test the quantum circuits.""" + test_amps = [-0.5, 0, 0.5] + rabi_ef = RoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) + + circs = transpile(rabi_ef.circuits(), self.backend, **rabi_ef.transpile_options.__dict__) + + for circ, amp in zip(circs, test_amps): + self.assertEqual(circ.count_ops()["Rabi"], 1) + + d0 = pulse.DriveChannel(0) + with pulse.build(name="x") as expected_x: + pulse.play(pulse.Drag(160, amp, 40, 0), d0) + + self.assertEqual(circ.calibrations["Rabi"][((0,), (amp,))], expected_x) + + def test_update(self): + """Test that the calibrations update properly.""" + + self.assertTrue(np.allclose(self.cals.get_parameter_value("amp", 0, "x"), 0.5)) + self.assertTrue(np.allclose(self.cals.get_parameter_value("amp", 0, "sx"), 0.25)) + + rabi_ef = RoughXSXAmplitudeCal(0, self.cals) + rabi_ef.run(RabiBackend(amplitude_to_angle=np.pi * 1.5)).block_for_results() + + tol = 0.002 + self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "x") - 0.333) < tol) + self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "sx") - 0.333 / 2) < tol) + + +class TestSpecializations(QiskitTestCase): + """Test the specialized versions of the calibration.""" + + def setUp(self): + """Setup the tests""" + super().setUp() + + library = FixedFrequencyTransmon() + + self.backend = FakeArmonk() + self.cals = BackendCalibrations(self.backend, library) + + # Add some pulses on the 1-2 transition. + d0 = pulse.DriveChannel(0) + with pulse.build(name="x12") as x12: + with pulse.frequency_offset(-300e6, d0): + pulse.play(pulse.Drag(160, Parameter("amp"), 40, 0.0), d0) + + with pulse.build(name="sx12") as sx12: + with pulse.frequency_offset(-300e6, d0): + pulse.play(pulse.Drag(160, Parameter("amp"), 40, 0.0), d0) + + self.cals.add_schedule(x12, 0) + self.cals.add_schedule(sx12, 0) + self.cals.add_parameter_value(0.4, "amp", 0, "x12") + self.cals.add_parameter_value(0.2, "amp", 0, "sx12") + + def test_ef_circuits(self): + """Test that we get the expected circuits with calibrations for the EF experiment.""" + + test_amps = [-0.5, 0, 0.5] + rabi_ef = EFRoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) + + circs = transpile(rabi_ef.circuits(), self.backend, **rabi_ef.transpile_options.__dict__) + + for circ, amp in zip(circs, test_amps): + + self.assertEqual(circ.count_ops()["x"], 1) + self.assertEqual(circ.count_ops()["Rabi"], 1) + + d0 = pulse.DriveChannel(0) + with pulse.build(name="x") as expected_x: + pulse.play(pulse.Drag(160, 0.5, 40, 0), d0) + + with pulse.build(name="x12") as expected_x12: + with pulse.frequency_offset(-300e6, d0): + pulse.play(pulse.Drag(160, amp, 40, 0), d0) + + self.assertEqual(circ.calibrations["x"][((0,), ())], expected_x) + self.assertEqual(circ.calibrations["Rabi"][((0,), (amp,))], expected_x12) + + def test_ef_update(self): + """Tes that we properly update the pulses on the 1<->2 transition.""" + + self.assertTrue(np.allclose(self.cals.get_parameter_value("amp", 0, "x12"), 0.4)) + self.assertTrue(np.allclose(self.cals.get_parameter_value("amp", 0, "sx12"), 0.2)) + + rabi_ef = EFRoughXSXAmplitudeCal(0, self.cals) + rabi_ef.run(RabiBackend(amplitude_to_angle=np.pi * 1.5)).block_for_results() + + tol = 0.002 + self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "x12") - 0.333) < tol) + self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "sx12") - 0.333 / 2) < tol) From 6156c4cd71a81fe462a9753f01acf045e7559ba3 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Tue, 26 Oct 2021 16:57:02 +0200 Subject: [PATCH 03/18] * Black and lint. --- qiskit_experiments/calibration_management/update_library.py | 2 +- test/calibration/experiments/test_rabi.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/qiskit_experiments/calibration_management/update_library.py b/qiskit_experiments/calibration_management/update_library.py index 007ada1fec..c699d1e25b 100644 --- a/qiskit_experiments/calibration_management/update_library.py +++ b/qiskit_experiments/calibration_management/update_library.py @@ -14,7 +14,7 @@ from abc import ABC from datetime import datetime, timezone -from typing import List, Optional, Tuple, Union +from typing import Optional, Union import numpy as np from qiskit.circuit import Parameter diff --git a/test/calibration/experiments/test_rabi.py b/test/calibration/experiments/test_rabi.py index d97f13332b..6244769068 100644 --- a/test/calibration/experiments/test_rabi.py +++ b/test/calibration/experiments/test_rabi.py @@ -110,8 +110,7 @@ def setUp(self): with pulse.build(name="x") as sched: with pulse.frequency_offset(-300e6, pulse.DriveChannel(self.qubit)): pulse.play( - pulse.Drag(160, Parameter("amp"), 40, 0.4), - pulse.DriveChannel(self.qubit) + pulse.Drag(160, Parameter("amp"), 40, 0.4), pulse.DriveChannel(self.qubit) ) self.sched = sched From 0986f6be7732b0a777e96e72acdf3d04fb0b07dc Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Wed, 27 Oct 2021 20:15:38 +0200 Subject: [PATCH 04/18] * Docs --- .../calibration/rough_amplitude_cal.py | 30 ++++++++++++------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index 26a9daf9cb..40b2bcb160 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -25,7 +25,11 @@ class RoughAmplitudeCal(BaseCalibrationExperiment, Rabi): - """A calibration version of the Rabi experiment.""" + """A calibration version of the Rabi experiment. + + # section: see_also + qiskit_experiments.library.characterization.rabi.Rabi + """ def __init__( self, @@ -38,13 +42,17 @@ def __init__( auto_update: bool = True, group: str = "default", ): - """see class :class:`Rabi` for details. + r"""see class :class:`Rabi` for details. Args: qubit: The qubit for which to run the rough amplitude calibration. calibrations: The calibrations instance with the schedules. - schedule_name: The name of the schedule to calibrate. + schedule_name: The name of the schedule to calibrate. Defaults to "x". + amplitudes: A list of amplitudes to scan. If None is given 51 amplitudes ranging + from -0.95 to 0.95 will be scanned. cal_parameter_name: The name of the parameter in the schedule to update. + target_angle: The target angle of the gate to calibrate this will default to a + :math:`\pi`-pulse. auto_update: Whether or not to automatically update the calibrations. By default this variable is set to True. group: The group of calibration parameters to use. The default value is "default". @@ -67,22 +75,24 @@ def __init__( self.transpile_options.inst_map = calibrations.default_inst_map # Set the pulses to update. + prev_amp = calibrations.get_parameter_value(cal_parameter_name, qubit, schedule_name) self.experiment_options.group = group self.experiment_options.angles_schedules = [ - (target_angle, cal_parameter_name, schedule_name) + (target_angle, cal_parameter_name, schedule_name, prev_amp) ] @classmethod def _default_experiment_options(cls): - """Default values for the fine amplitude calibration experiment. + """Default values for the rough amplitude calibration experiment. Experiment Options: result_index (int): The index of the result from which to update the calibrations. - angles_schedules List(float, str, str, float): A list of parameter update information. + angles_schedules (list(float, str, str, float)): A list of parameter update information. Each entry of the list is a tuple with four entries: the target angle of the rotation, the name of the amplitude parameter to update, the name of the schedule containing the amplitude parameter to update, and the previous value of the - amplitude parameter to update. + amplitude parameter to update. This allows one experiment to update several + schedules, see for example :class:`RoughXSXAmplitudeCal`. group (str): The calibration group to which the parameter belongs. This will default to the value "default". """ @@ -123,7 +133,7 @@ def _add_cal_metadata(self, circuits: List[QuantumCircuit]): return circuits def update_calibrations(self, experiment_data: ExperimentData): - r"""Update the amplitude of one or several pulses. + r"""Update the amplitude of one or several schedules. The update rule extracts the rate of the oscillation from the fit to the cosine function. Recall that the amplitude is the x-axis in the analysis of the :class:`Rabi` experiment. @@ -138,8 +148,8 @@ def update_calibrations(self, experiment_data: ExperimentData): for "x" and "sx" gates, respectively) and :math:`\omega` is the rate of the oscillation. Args: - experiment_data: The experiment data from which to extract the measured over/under - rotation used to adjust the amplitude. + experiment_data: The experiment data from which to extract the measured Rabi oscillation + used to set the pulse amplitude. """ data = experiment_data.data() From 35a0005efadb6200c5a7700165e4f33319194131 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Wed, 27 Oct 2021 20:20:46 +0200 Subject: [PATCH 05/18] * Docs. --- .../calibration/rough_amplitude_cal.py | 2 +- .../library/characterization/rabi.py | 21 +------------------ 2 files changed, 2 insertions(+), 21 deletions(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index 40b2bcb160..1091d34379 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -26,7 +26,7 @@ class RoughAmplitudeCal(BaseCalibrationExperiment, Rabi): """A calibration version of the Rabi experiment. - + # section: see_also qiskit_experiments.library.characterization.rabi.Rabi """ diff --git a/qiskit_experiments/library/characterization/rabi.py b/qiskit_experiments/library/characterization/rabi.py index 7a0955334d..a431f81f46 100644 --- a/qiskit_experiments/library/characterization/rabi.py +++ b/qiskit_experiments/library/characterization/rabi.py @@ -71,12 +71,6 @@ def _default_run_options(cls) -> Options: def _default_experiment_options(cls) -> Options: """Default values for the pulse if no schedule is given. - Users can set a schedule by doing - - .. code-block:: - - rabi.set_experiment_options(schedule=rabi_schedule) - Experiment Options: amplitudes (iterable): The list of amplitude values to scan. schedule (ScheduleBlock): The schedule for the Rabi pulse. This schedule must have @@ -153,12 +147,6 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: Returns: A list of circuits with a rabi gate with an attached schedule. Each schedule will have a different value of the scanned amplitude. - - Raises: - CalibrationError: - - If the user-provided schedule does not contain a channel with an index - that matches the qubit on which to run the Rabi experiment. - - If the user provided schedule has more than one free parameter. """ # Create template circuit @@ -186,7 +174,7 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: class EFRabi(Rabi): - """An experiment that scans the amplitude of a pulse to calibrate rotations between 1 and 2. + """An experiment that scans the amplitude of a pulse inducing rotations between 1 and 2. # section: overview @@ -205,13 +193,6 @@ class EFRabi(Rabi): measure: 1/══════════════════════╩═ 0 - # section: example - Users can set a schedule by doing - - .. code-block:: - - ef_rabi.set_experiment_options(schedule=rabi_schedule) - """ @classmethod From 902a77d782c02fcc671adc6fe10b19acb0bf39f7 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 10:40:46 +0200 Subject: [PATCH 06/18] * Updated NB and caught some bugs. --- docs/tutorials/calibrating_armonk.ipynb | 355 ++++++++++-------- .../calibration/rough_amplitude_cal.py | 11 +- .../library/characterization/rabi.py | 9 +- 3 files changed, 212 insertions(+), 163 deletions(-) diff --git a/docs/tutorials/calibrating_armonk.ipynb b/docs/tutorials/calibrating_armonk.ipynb index db4e77529d..6edf33b9b2 100644 --- a/docs/tutorials/calibrating_armonk.ipynb +++ b/docs/tutorials/calibrating_armonk.ipynb @@ -183,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 16, "id": "fa22b8a4", "metadata": {}, "outputs": [ @@ -221,68 +221,68 @@ " \n", " \n", " 0\n", - " β\n", + " σ\n", " ()\n", - " sx\n", - " 0.000000e+00\n", + " x\n", + " 8.000000e+01+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496348+0200\n", + " 2021-10-28 10:27:44.953702+0200\n", " None\n", " \n", " \n", " 1\n", - " σ\n", - " ()\n", - " sx\n", - " 8.000000e+01\n", + " qubit_lo_freq\n", + " (0,)\n", + " None\n", + " 4.971589e+09+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496341+0200\n", + " 2021-10-28 10:27:44.953446+0200\n", " None\n", " \n", " \n", " 2\n", - " amp\n", + " β\n", " ()\n", " sx\n", - " 2.500000e-01\n", + " 0.000000e+00+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496333+0200\n", + " 2021-10-28 10:27:44.953730+0200\n", " None\n", " \n", " \n", " 3\n", " duration\n", " ()\n", - " sx\n", - " 3.200000e+02\n", + " x\n", + " 3.200000e+02+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496325+0200\n", + " 2021-10-28 10:27:44.953694+0200\n", " None\n", " \n", " \n", " 4\n", - " qubit_lo_freq\n", - " (0,)\n", - " None\n", - " 4.971593e+09\n", + " duration\n", + " ()\n", + " sx\n", + " 3.200000e+02+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.495991+0200\n", + " 2021-10-28 10:27:44.953716+0200\n", " None\n", " \n", " \n", " 5\n", - " meas_lo_freq\n", - " (0,)\n", - " None\n", - " 6.993371e+09\n", + " amp\n", + " ()\n", + " sx\n", + " 2.500000e-01+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496017+0200\n", + " 2021-10-28 10:27:44.953709+0200\n", " None\n", " \n", " \n", @@ -290,43 +290,65 @@ " β\n", " ()\n", " x\n", - " 0.000000e+00\n", + " 0.000000e+00+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496317+0200\n", + " 2021-10-28 10:27:44.953685+0200\n", " None\n", " \n", " \n", " 7\n", - " σ\n", - " ()\n", + " amp\n", + " (0,)\n", " x\n", - " 8.000000e+01\n", + " 8.578134e-01+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496309+0200\n", - " None\n", + " 2021-10-28 10:37:56.254000+0200\n", + " aa8b9513-a1d8-48b5-82ed-2e3538860ad3\n", " \n", " \n", " 8\n", - " amp\n", - " ()\n", - " x\n", - " 5.000000e-01\n", + " meas_lo_freq\n", + " (0,)\n", + " None\n", + " 6.993371e+09+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496299+0200\n", + " 2021-10-28 10:27:44.953469+0200\n", " None\n", " \n", " \n", " 9\n", - " duration\n", + " σ\n", + " ()\n", + " sx\n", + " 8.000000e+01+0.000000e+00j\n", + " default\n", + " True\n", + " 2021-10-28 10:27:44.953723+0200\n", + " None\n", + " \n", + " \n", + " 10\n", + " amp\n", + " (0,)\n", + " sx\n", + " 4.289067e-01+0.000000e+00j\n", + " default\n", + " True\n", + " 2021-10-28 10:37:56.254000+0200\n", + " aa8b9513-a1d8-48b5-82ed-2e3538860ad3\n", + " \n", + " \n", + " 11\n", + " amp\n", " ()\n", " x\n", - " 3.200000e+02\n", + " 5.000000e-01+0.000000e+00j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496281+0200\n", + " 2021-10-28 10:27:44.953672+0200\n", " None\n", " \n", " \n", @@ -334,32 +356,36 @@ "" ], "text/plain": [ - " parameter qubits schedule value group valid \\\n", - "0 β () sx 0.000000e+00 default True \n", - "1 σ () sx 8.000000e+01 default True \n", - "2 amp () sx 2.500000e-01 default True \n", - "3 duration () sx 3.200000e+02 default True \n", - "4 qubit_lo_freq (0,) None 4.971593e+09 default True \n", - "5 meas_lo_freq (0,) None 6.993371e+09 default True \n", - "6 β () x 0.000000e+00 default True \n", - "7 σ () x 8.000000e+01 default True \n", - "8 amp () x 5.000000e-01 default True \n", - "9 duration () x 3.200000e+02 default True \n", + " parameter qubits schedule value group valid \\\n", + "0 σ () x 8.000000e+01+0.000000e+00j default True \n", + "1 qubit_lo_freq (0,) None 4.971589e+09+0.000000e+00j default True \n", + "2 β () sx 0.000000e+00+0.000000e+00j default True \n", + "3 duration () x 3.200000e+02+0.000000e+00j default True \n", + "4 duration () sx 3.200000e+02+0.000000e+00j default True \n", + "5 amp () sx 2.500000e-01+0.000000e+00j default True \n", + "6 β () x 0.000000e+00+0.000000e+00j default True \n", + "7 amp (0,) x 8.578134e-01+0.000000e+00j default True \n", + "8 meas_lo_freq (0,) None 6.993371e+09+0.000000e+00j default True \n", + "9 σ () sx 8.000000e+01+0.000000e+00j default True \n", + "10 amp (0,) sx 4.289067e-01+0.000000e+00j default True \n", + "11 amp () x 5.000000e-01+0.000000e+00j default True \n", "\n", - " date_time exp_id \n", - "0 2021-10-21 14:21:13.496348+0200 None \n", - "1 2021-10-21 14:21:13.496341+0200 None \n", - "2 2021-10-21 14:21:13.496333+0200 None \n", - "3 2021-10-21 14:21:13.496325+0200 None \n", - "4 2021-10-21 14:21:13.495991+0200 None \n", - "5 2021-10-21 14:21:13.496017+0200 None \n", - "6 2021-10-21 14:21:13.496317+0200 None \n", - "7 2021-10-21 14:21:13.496309+0200 None \n", - "8 2021-10-21 14:21:13.496299+0200 None \n", - "9 2021-10-21 14:21:13.496281+0200 None " + " date_time exp_id \n", + "0 2021-10-28 10:27:44.953702+0200 None \n", + "1 2021-10-28 10:27:44.953446+0200 None \n", + "2 2021-10-28 10:27:44.953730+0200 None \n", + "3 2021-10-28 10:27:44.953694+0200 None \n", + "4 2021-10-28 10:27:44.953716+0200 None \n", + "5 2021-10-28 10:27:44.953709+0200 None \n", + "6 2021-10-28 10:27:44.953685+0200 None \n", + "7 2021-10-28 10:37:56.254000+0200 aa8b9513-a1d8-48b5-82ed-2e3538860ad3 \n", + "8 2021-10-28 10:27:44.953469+0200 None \n", + "9 2021-10-28 10:27:44.953723+0200 None \n", + "10 2021-10-28 10:37:56.254000+0200 aa8b9513-a1d8-48b5-82ed-2e3538860ad3 \n", + "11 2021-10-28 10:27:44.953672+0200 None " ] }, - "execution_count": 9, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -379,13 +405,13 @@ "source": [ "freq01_estimate = backend.defaults().qubit_freq_est[qubit]\n", "frequencies = np.linspace(freq01_estimate -15e6, freq01_estimate + 15e6, 51)\n", - "spec = RoughFrequencyCal(qubit, cals, frequencies)\n", + "spec = RoughFrequencyCal(qubit, cals, frequencies, backend=backend)\n", "spec.set_experiment_options(amp=0.1)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "91184061", "metadata": {}, "outputs": [ @@ -396,30 +422,30 @@ "
" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "circuit = spec.circuits(backend)[0]\n", + "circuit = spec.circuits()[0]\n", "circuit.draw(output=\"mpl\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "32a49399", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -430,28 +456,28 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "1e24ce2a", "metadata": {}, "outputs": [], "source": [ - "spec_data = spec.run(backend).block_for_results()" + "spec_data = spec.run().block_for_results()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "e880af97", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -462,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "6e8e067c", "metadata": {}, "outputs": [ @@ -472,8 +498,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: f01\n", - "- value: 4971617198.1562395 ± 48877.278375288435 Hz\n", - "- χ²: 1.2265631671328414\n", + "- value: 4971657997.745945 ± 45050.505720374684 Hz\n", + "- χ²: 0.7650116404414524\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -494,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "6937956d", "metadata": {}, "outputs": [ @@ -532,13 +558,13 @@ " \n", " \n", " 0\n", - " meas_lo_freq\n", + " qubit_lo_freq\n", " (0,)\n", " None\n", - " 6.993371e+09\n", + " 4.971589e+09\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496017+0200\n", + " 2021-10-28 09:22:53.219031+0200\n", " None\n", " \n", " \n", @@ -546,22 +572,22 @@ " qubit_lo_freq\n", " (0,)\n", " None\n", - " 4.971593e+09\n", + " 4.971658e+09\n", " default\n", " True\n", - " 2021-10-21 14:21:13.495991+0200\n", - " None\n", + " 2021-10-28 09:27:39.803000+0200\n", + " 595c08f2-ed79-4c25-8843-803c569b4e90\n", " \n", " \n", " 2\n", - " qubit_lo_freq\n", + " meas_lo_freq\n", " (0,)\n", " None\n", - " 4.971617e+09\n", + " 6.993371e+09\n", " default\n", " True\n", - " 2021-10-21 14:26:42.953000+0200\n", - " 553c95bf-e578-4064-9b17-68a07b84a7f0\n", + " 2021-10-28 09:22:53.219055+0200\n", + " None\n", " \n", " \n", "\n", @@ -569,17 +595,17 @@ ], "text/plain": [ " parameter qubits schedule value group valid \\\n", - "0 meas_lo_freq (0,) None 6.993371e+09 default True \n", - "1 qubit_lo_freq (0,) None 4.971593e+09 default True \n", - "2 qubit_lo_freq (0,) None 4.971617e+09 default True \n", + "0 qubit_lo_freq (0,) None 4.971589e+09 default True \n", + "1 qubit_lo_freq (0,) None 4.971658e+09 default True \n", + "2 meas_lo_freq (0,) None 6.993371e+09 default True \n", "\n", " date_time exp_id \n", - "0 2021-10-21 14:21:13.496017+0200 None \n", - "1 2021-10-21 14:21:13.495991+0200 None \n", - "2 2021-10-21 14:26:42.953000+0200 553c95bf-e578-4064-9b17-68a07b84a7f0 " + "0 2021-10-28 09:22:53.219031+0200 None \n", + "1 2021-10-28 09:27:39.803000+0200 595c08f2-ed79-4c25-8843-803c569b4e90 \n", + "2 2021-10-28 09:22:53.219055+0200 None " ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -603,58 +629,91 @@ "source": [ "## 2. Calibrating the pulse amplitudes with a Rabi experiment\n", "\n", - "In the Rabi experiment we apply a pulse at the frequency of the qubit and scan its amplitude to find the amplitude that creates a rotation of a desired angle." + "In the Rabi experiment we apply a pulse at the frequency of the qubit and scan its amplitude to find the amplitude that creates a rotation of a desired angle. We do this with the calibration experiment `RoughXSXAmplitudeCal` this is a specialization of the `Rabi` experiment that will update the calibrations for both the `X` pulse and the `SX` pulse using a single experiment." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "id": "ed4a5f77", "metadata": {}, "outputs": [], "source": [ - "from qiskit_experiments.library.calibration import Rabi\n", - "from qiskit_experiments.calibration_management.update_library import Amplitude" + "from qiskit_experiments.library.calibration import RoughXSXAmplitudeCal" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "id": "8227b8ba", "metadata": {}, "outputs": [], "source": [ - "rabi = Rabi(qubit)\n", - "rabi.set_experiment_options(\n", - " amplitudes=np.linspace(-0.95, 0.95, 51), \n", - " schedule=cals.get_schedule(\"x\", (qubit,), assign_params={\"amp\": Parameter(\"amp\")}),\n", - ")" + "rabi = RoughXSXAmplitudeCal(qubit, cals, backend=backend)" + ] + }, + { + "cell_type": "markdown", + "id": "1b425031", + "metadata": {}, + "source": [ + "The rough amplitude calibration is therefore a Rabi experiment in which each circuit contains a pulse with a gate. Different circuits correspond to pulses with different amplitudes." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b82cf6dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rabi.circuits()[0].draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "f8ecc750", + "metadata": {}, + "source": [ + "After the experiment completes the value of the amplitudes in the calibrations will automatically be updated. This behaviour can be controlled using the `auto_update` argument given to the calibration experiment at initialization." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 11, "id": "68d32b29", "metadata": {}, "outputs": [], "source": [ - "rabi_data = rabi.run(backend).block_for_results()" + "rabi_data = rabi.run().block_for_results()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "id": "9eefc00c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 20, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -665,7 +724,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 13, "id": "444d829c", "metadata": {}, "outputs": [ @@ -675,8 +734,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: rabi_rate\n", - "- value: 0.5773601216615961 ± 0.00302334045912944\n", - "- χ²: 1.7757334563985634\n", + "- value: 0.5828773180419505 ± 0.0027186379727953116\n", + "- χ²: 1.6337913847682912\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -689,17 +748,7 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "f883b472", - "metadata": {}, - "outputs": [], - "source": [ - "Amplitude.update(cals, rabi_data, angles_schedules=[(np.pi, \"amp\", \"x\"), (np.pi/2, \"amp\", \"sx\")])" - ] - }, - { - "cell_type": "code", - "execution_count": 23, + "execution_count": 17, "id": "7fa0e4b4", "metadata": {}, "outputs": [ @@ -738,46 +787,46 @@ " \n", " 0\n", " amp\n", - " ()\n", - " sx\n", - " 0.250000+0.000000j\n", + " (0,)\n", + " x\n", + " 0.857813+0.000000j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496333+0200\n", - " None\n", + " 2021-10-28 10:37:56.254000+0200\n", + " aa8b9513-a1d8-48b5-82ed-2e3538860ad3\n", " \n", " \n", " 1\n", " amp\n", - " (0,)\n", + " ()\n", " sx\n", - " 0.433005+0.000000j\n", + " 0.250000+0.000000j\n", " default\n", " True\n", - " 2021-10-21 14:39:49.487000+0200\n", - " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", + " 2021-10-28 10:27:44.953709+0200\n", + " None\n", " \n", " \n", " 2\n", " amp\n", - " ()\n", - " x\n", - " 0.500000+0.000000j\n", + " (0,)\n", + " sx\n", + " 0.428907+0.000000j\n", " default\n", " True\n", - " 2021-10-21 14:21:13.496299+0200\n", - " None\n", + " 2021-10-28 10:37:56.254000+0200\n", + " aa8b9513-a1d8-48b5-82ed-2e3538860ad3\n", " \n", " \n", " 3\n", " amp\n", - " (0,)\n", + " ()\n", " x\n", - " 0.866011+0.000000j\n", + " 0.500000+0.000000j\n", " default\n", " True\n", - " 2021-10-21 14:39:49.487000+0200\n", - " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", + " 2021-10-28 10:27:44.953672+0200\n", + " None\n", " \n", " \n", "\n", @@ -785,19 +834,19 @@ ], "text/plain": [ " parameter qubits schedule value group valid \\\n", - "0 amp () sx 0.250000+0.000000j default True \n", - "1 amp (0,) sx 0.433005+0.000000j default True \n", - "2 amp () x 0.500000+0.000000j default True \n", - "3 amp (0,) x 0.866011+0.000000j default True \n", + "0 amp (0,) x 0.857813+0.000000j default True \n", + "1 amp () sx 0.250000+0.000000j default True \n", + "2 amp (0,) sx 0.428907+0.000000j default True \n", + "3 amp () x 0.500000+0.000000j default True \n", "\n", " date_time exp_id \n", - "0 2021-10-21 14:21:13.496333+0200 None \n", - "1 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", - "2 2021-10-21 14:21:13.496299+0200 None \n", - "3 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 " + "0 2021-10-28 10:37:56.254000+0200 aa8b9513-a1d8-48b5-82ed-2e3538860ad3 \n", + "1 2021-10-28 10:27:44.953709+0200 None \n", + "2 2021-10-28 10:37:56.254000+0200 aa8b9513-a1d8-48b5-82ed-2e3538860ad3 \n", + "3 2021-10-28 10:27:44.953672+0200 None " ] }, - "execution_count": 23, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index 9eb84aa876..dc7282cfc3 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -120,7 +120,7 @@ def _add_cal_metadata(self, circuits: List[QuantumCircuit]): """ param_values = [] - for angle, param_name, schedule_name in self.experiment_options.angles_schedules: + for angle, param_name, schedule_name, _ in self.experiment_options.angles_schedules: param_val = self._cals.get_parameter_value( param_name, self._physical_qubits, @@ -195,7 +195,10 @@ def __init__( target_angle=np.pi, ) - self.experiment_options.angles_schedules = [(np.pi, "amp", "x"), (np.pi / 2, "amp", "sx")] + self.experiment_options.angles_schedules = [ + (np.pi, "amp", "x", None), + (np.pi / 2, "amp", "sx", None) + ] class EFRoughXSXAmplitudeCal(RoughAmplitudeCal): @@ -231,8 +234,8 @@ def __init__( ) self.experiment_options.angles_schedules = [ - (np.pi, "amp", "x" + ef_pulse_label), - (np.pi / 2, "amp", "sx" + ef_pulse_label), + (np.pi, "amp", "x" + ef_pulse_label, None), + (np.pi / 2, "amp", "sx" + ef_pulse_label, None), ] def _pre_circuit(self) -> QuantumCircuit: diff --git a/qiskit_experiments/library/characterization/rabi.py b/qiskit_experiments/library/characterization/rabi.py index 080234dac7..53f3062aa8 100644 --- a/qiskit_experiments/library/characterization/rabi.py +++ b/qiskit_experiments/library/characterization/rabi.py @@ -143,12 +143,9 @@ def _template_circuit(self) -> Tuple[QuantumCircuit, Parameter]: return circuit, param - def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: + def circuits(self) -> List[QuantumCircuit]: """Create the circuits for the Rabi experiment. - Args: - backend: A backend object. - Returns: A list of circuits with a rabi gate with an attached schedule. Each schedule will have a different value of the scanned amplitude. @@ -170,8 +167,8 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: "amplitude": amp, } - if backend: - assigned_circ.metadata["dt"] = getattr(backend.configuration(), "dt", "n.a.") + if self.backend: + assigned_circ.metadata["dt"] = getattr(self.backend.configuration(), "dt", "n.a.") circs.append(assigned_circ) From 7042b38e55f33153209fd1fdc207a3b6aee39dc6 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 10:47:05 +0200 Subject: [PATCH 07/18] * Lint and removed updater amplitude test as Amplitude no longer exists. --- test/calibration/experiments/test_rabi.py | 3 +- test/calibration/test_update_library.py | 42 +---------------------- 2 files changed, 2 insertions(+), 43 deletions(-) diff --git a/test/calibration/experiments/test_rabi.py b/test/calibration/experiments/test_rabi.py index 6ab7e49d00..443532a16a 100644 --- a/test/calibration/experiments/test_rabi.py +++ b/test/calibration/experiments/test_rabi.py @@ -123,7 +123,6 @@ def test_ef_rabi_end_to_end(self): # Note that the backend is not sophisticated enough to simulate an e-f # transition so we run the test with a tiny frequency shift, still driving the e-g transition. - freq_shift = 0.01 rabi = EFRabi(self.qubit, self.sched) rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 21)) expdata = rabi.run(backend) @@ -144,7 +143,7 @@ def test_ef_rabi_circuit(self): rabi12 = EFRabi(2, sched) rabi12.set_experiment_options(amplitudes=[0.5]) - circ = rabi12.circuits(RabiBackend())[0] + circ = rabi12.circuits()[0] with pulse.build() as expected: pulse.shift_frequency(anharm, pulse.DriveChannel(2)) diff --git a/test/calibration/test_update_library.py b/test/calibration/test_update_library.py index 94f97f6e58..c0c8fbca93 100644 --- a/test/calibration/test_update_library.py +++ b/test/calibration/test_update_library.py @@ -12,7 +12,6 @@ """Test the calibration update library.""" -from test.calibration.experiments.test_rabi import RabiBackend from test.test_qubit_spectroscopy import SpectroscopyBackend import numpy as np @@ -22,12 +21,10 @@ import qiskit.pulse as pulse from qiskit.test.mock import FakeAthens -from qiskit_experiments.library import Rabi, FineXDrag, DragCal, QubitSpectroscopy +from qiskit_experiments.library import FineXDrag, DragCal, QubitSpectroscopy from qiskit_experiments.calibration_management.calibrations import Calibrations -from qiskit_experiments.exceptions import CalibrationError from qiskit_experiments.calibration_management.update_library import ( Frequency, - Amplitude, Drag, FineDragUpdater, ) @@ -61,43 +58,6 @@ def setUp(self): self.cals.add_parameter_value(0.2, "amp", self.qubit, "xp") self.cals.add_parameter_value(0.1, "amp", self.qubit, "x90p") - def test_amplitude(self): - """Test amplitude update from Rabi.""" - - rabi = Rabi(self.qubit) - rabi.set_experiment_options(amplitudes=np.linspace(-0.95, 0.95, 21)) - exp_data = rabi.run(RabiBackend()) - exp_data.block_for_results() - - with self.assertRaises(CalibrationError): - self.cals.get_schedule("xp", qubits=0) - - to_update = [(np.pi, "amp", "xp"), (np.pi / 2, "amp", self.x90p)] - - self.assertEqual(len(self.cals.parameters_table()), 2) - - Amplitude.update(self.cals, exp_data, angles_schedules=to_update) - - with self.assertRaises(CalibrationError): - self.cals.get_schedule("xp", qubits=0) - - self.assertEqual(len(self.cals.parameters_table()["data"]), 4) - - # Now check the corresponding schedules - result = exp_data.analysis_results(1) - rate = 2 * np.pi * result.value.value - amp = np.round(np.pi / rate, decimals=8) - with pulse.build(name="xp") as expected: - pulse.play(pulse.Gaussian(160, amp, 40), pulse.DriveChannel(self.qubit)) - - self.assertEqual(self.cals.get_schedule("xp", qubits=self.qubit), expected) - - amp = np.round(0.5 * np.pi / rate, decimals=8) - with pulse.build(name="xp") as expected: - pulse.play(pulse.Gaussian(160, amp, 40), pulse.DriveChannel(self.qubit)) - - self.assertEqual(self.cals.get_schedule("x90p", qubits=self.qubit), expected) - class TestFrequencyUpdate(QiskitTestCase): """Test the frequency update function in the update library.""" From c1fa1528b6d9123b48625b94767715648657f484 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 10:50:48 +0200 Subject: [PATCH 08/18] * Black --- qiskit_experiments/library/calibration/rough_amplitude_cal.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index dc7282cfc3..fe07551acc 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -197,7 +197,7 @@ def __init__( self.experiment_options.angles_schedules = [ (np.pi, "amp", "x", None), - (np.pi / 2, "amp", "sx", None) + (np.pi / 2, "amp", "sx", None), ] From 632e3257fbc11a0dc2f8ebb8f4efab39c600b391 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 12:00:55 +0200 Subject: [PATCH 09/18] * Test lint --- test/calibration/experiments/test_fine_amplitude.py | 8 ++++---- test/calibration/experiments/test_rough_amplitude.py | 6 +++--- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index 0ba4cad1e4..91dd927926 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -200,7 +200,7 @@ def test_run_x_cal(self): amp_cal = FineXAmplitudeCal(0, self.cals, "x") - circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) with pulse.build(name="x") as expected_x: pulse.play(pulse.Drag(160, 0.5, 40, 0), pulse.DriveChannel(0)) @@ -216,7 +216,7 @@ def test_run_x_cal(self): d_theta = exp_data.analysis_results(1).value.value new_amp = init_amp * np.pi / (np.pi + d_theta) - circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) x_cal = circs[5].calibrations["x"][((0,), ())] @@ -238,7 +238,7 @@ def test_run_sx_cal(self): amp_cal = FineSXAmplitudeCal(0, self.cals, "sx") - circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) with pulse.build(name="sx") as expected_sx: pulse.play(pulse.Drag(160, 0.25, 40, 0), pulse.DriveChannel(0)) @@ -250,7 +250,7 @@ def test_run_sx_cal(self): d_theta = exp_data.analysis_results(1).value.value new_amp = init_amp * (np.pi / 2) / (np.pi / 2 + d_theta) - circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) sx_cal = circs[5].calibrations["sx"][((0,), ())] diff --git a/test/calibration/experiments/test_rough_amplitude.py b/test/calibration/experiments/test_rough_amplitude.py index c4d6558f1c..fffe1261f1 100644 --- a/test/calibration/experiments/test_rough_amplitude.py +++ b/test/calibration/experiments/test_rough_amplitude.py @@ -40,9 +40,9 @@ def setUp(self): def test_circuits(self): """Test the quantum circuits.""" test_amps = [-0.5, 0, 0.5] - rabi_ef = RoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) + rabi = RoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) - circs = transpile(rabi_ef.circuits(), self.backend, **rabi_ef.transpile_options.__dict__) + circs = transpile(rabi.circuits(), self.backend, inst_map=rabi.transpile_options.inst_map) for circ, amp in zip(circs, test_amps): self.assertEqual(circ.count_ops()["Rabi"], 1) @@ -100,7 +100,7 @@ def test_ef_circuits(self): test_amps = [-0.5, 0, 0.5] rabi_ef = EFRoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) - circs = transpile(rabi_ef.circuits(), self.backend, **rabi_ef.transpile_options.__dict__) + circs = transpile(rabi_ef.circuits(), self.backend, inst_map=rabi_ef.transpile_options.inst_map) for circ, amp in zip(circs, test_amps): From aa4db729721f5f7d612268d3628cbed281676848 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 12:01:23 +0200 Subject: [PATCH 10/18] * Black. --- .../experiments/test_fine_amplitude.py | 16 ++++++++++++---- .../experiments/test_rough_amplitude.py | 4 +++- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index 91dd927926..cdc12298c7 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -200,7 +200,9 @@ def test_run_x_cal(self): amp_cal = FineXAmplitudeCal(0, self.cals, "x") - circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) + circs = transpile( + amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map + ) with pulse.build(name="x") as expected_x: pulse.play(pulse.Drag(160, 0.5, 40, 0), pulse.DriveChannel(0)) @@ -216,7 +218,9 @@ def test_run_x_cal(self): d_theta = exp_data.analysis_results(1).value.value new_amp = init_amp * np.pi / (np.pi + d_theta) - circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) + circs = transpile( + amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map + ) x_cal = circs[5].calibrations["x"][((0,), ())] @@ -238,7 +242,9 @@ def test_run_sx_cal(self): amp_cal = FineSXAmplitudeCal(0, self.cals, "sx") - circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) + circs = transpile( + amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map + ) with pulse.build(name="sx") as expected_sx: pulse.play(pulse.Drag(160, 0.25, 40, 0), pulse.DriveChannel(0)) @@ -250,7 +256,9 @@ def test_run_sx_cal(self): d_theta = exp_data.analysis_results(1).value.value new_amp = init_amp * (np.pi / 2) / (np.pi / 2 + d_theta) - circs = transpile(amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map) + circs = transpile( + amp_cal.circuits(), self.backend, inst_map=amp_cal.transpile_options.inst_map + ) sx_cal = circs[5].calibrations["sx"][((0,), ())] diff --git a/test/calibration/experiments/test_rough_amplitude.py b/test/calibration/experiments/test_rough_amplitude.py index fffe1261f1..f104e2f387 100644 --- a/test/calibration/experiments/test_rough_amplitude.py +++ b/test/calibration/experiments/test_rough_amplitude.py @@ -100,7 +100,9 @@ def test_ef_circuits(self): test_amps = [-0.5, 0, 0.5] rabi_ef = EFRoughXSXAmplitudeCal(0, self.cals, amplitudes=test_amps) - circs = transpile(rabi_ef.circuits(), self.backend, inst_map=rabi_ef.transpile_options.inst_map) + circs = transpile( + rabi_ef.circuits(), self.backend, inst_map=rabi_ef.transpile_options.inst_map + ) for circ, amp in zip(circs, test_amps): From 42f536cc60df1c5142ee1d1e34ad0e93b23d6e0b Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 16:21:43 +0200 Subject: [PATCH 11/18] * Removed dt info --- qiskit_experiments/library/characterization/rabi.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/qiskit_experiments/library/characterization/rabi.py b/qiskit_experiments/library/characterization/rabi.py index 53f3062aa8..60de5f204c 100644 --- a/qiskit_experiments/library/characterization/rabi.py +++ b/qiskit_experiments/library/characterization/rabi.py @@ -167,9 +167,6 @@ def circuits(self) -> List[QuantumCircuit]: "amplitude": amp, } - if self.backend: - assigned_circ.metadata["dt"] = getattr(self.backend.configuration(), "dt", "n.a.") - circs.append(assigned_circ) return circs From 8e504186fc8f7ac784c7f4499e8a6c9d8a18570c Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 16:27:57 +0200 Subject: [PATCH 12/18] * rabi_rate_12 --- .../library/calibration/rough_amplitude_cal.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index fe07551acc..e12847daba 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -77,6 +77,7 @@ def __init__( # Needed for subclasses that will drive other transitions than the 0<->1 transition. self.transpile_options.inst_map = calibrations.default_inst_map + self._analysis_param_name = "rabi_rate" # Set the pulses to update. prev_amp = calibrations.get_parameter_value(cal_parameter_name, qubit, schedule_name) @@ -163,7 +164,11 @@ def update_calibrations(self, experiment_data: ExperimentData): result_index = self.experiment_options.result_index group = data[0]["metadata"]["cal_group"] - rate = 2 * np.pi * BaseUpdater.get_value(experiment_data, "rabi_rate", result_index) + rate = 2 * np.pi * BaseUpdater.get_value( + experiment_data, + self._analysis_param_name, + result_index + ) for angle, param, schedule, prev_amp in data[0]["metadata"]["angles_schedules"]: @@ -233,6 +238,7 @@ def __init__( target_angle=np.pi, ) + self._analysis_param_name = "rabi_rate_12" self.experiment_options.angles_schedules = [ (np.pi, "amp", "x" + ef_pulse_label, None), (np.pi / 2, "amp", "sx" + ef_pulse_label, None), From ca833ad91028058b913f09c69ae71c9ded516dc8 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 16:36:52 +0200 Subject: [PATCH 13/18] * Named tuple. --- .../calibration/rough_amplitude_cal.py | 53 +++++++++++++++---- 1 file changed, 42 insertions(+), 11 deletions(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index e12847daba..d85c96067f 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -12,6 +12,7 @@ """Rough amplitude calibration using Rabi.""" +from collections import namedtuple from typing import Iterable, List, Optional import numpy as np @@ -24,6 +25,10 @@ from qiskit_experiments.library.characterization import Rabi from qiskit_experiments.calibration_management.update_library import BaseUpdater +AnglesSchedules = namedtuple( + "AnglesSchedules", ["target_angle", "parameter", "schedule", "previous_value"] +) + class RoughAmplitudeCal(BaseCalibrationExperiment, Rabi): """A calibration version of the Rabi experiment. @@ -83,7 +88,12 @@ def __init__( prev_amp = calibrations.get_parameter_value(cal_parameter_name, qubit, schedule_name) self.experiment_options.group = group self.experiment_options.angles_schedules = [ - (target_angle, cal_parameter_name, schedule_name, prev_amp) + AnglesSchedules( + target_angle=target_angle, + parameter=cal_parameter_name, + schedule=schedule_name, + previous_value=prev_amp, + ) ] @classmethod @@ -104,7 +114,9 @@ def _default_experiment_options(cls): options = super()._default_experiment_options() options.result_index = -1 - options.angles_schedules = [(np.pi, "amp", "x", None)] + options.angles_schedules = [ + AnglesSchedules(target_angle=np.pi, parameter="amp", schedule="x", previous_value=None) + ] options.group = "default" return options @@ -129,7 +141,14 @@ def _add_cal_metadata(self, circuits: List[QuantumCircuit]): group=self.experiment_options.group, ) - param_values.append((angle, param_name, schedule_name, param_val)) + param_values.append( + AnglesSchedules( + target_angle=angle, + parameter=param_name, + schedule=schedule_name, + previous_value=param_val, + ) + ) for circuit in circuits: circuit.metadata["angles_schedules"] = param_values @@ -164,10 +183,10 @@ def update_calibrations(self, experiment_data: ExperimentData): result_index = self.experiment_options.result_index group = data[0]["metadata"]["cal_group"] - rate = 2 * np.pi * BaseUpdater.get_value( - experiment_data, - self._analysis_param_name, - result_index + rate = ( + 2 + * np.pi + * BaseUpdater.get_value(experiment_data, self._analysis_param_name, result_index) ) for angle, param, schedule, prev_amp in data[0]["metadata"]["angles_schedules"]: @@ -201,8 +220,10 @@ def __init__( ) self.experiment_options.angles_schedules = [ - (np.pi, "amp", "x", None), - (np.pi / 2, "amp", "sx", None), + AnglesSchedules(target_angle=np.pi, parameter="amp", schedule="x", previous_value=None), + AnglesSchedules( + target_angle=np.pi / 2, parameter="amp", schedule="sx", previous_value=None + ), ] @@ -240,8 +261,18 @@ def __init__( self._analysis_param_name = "rabi_rate_12" self.experiment_options.angles_schedules = [ - (np.pi, "amp", "x" + ef_pulse_label, None), - (np.pi / 2, "amp", "sx" + ef_pulse_label, None), + AnglesSchedules( + target_angle=np.pi, + parameter="amp", + schedule="x" + ef_pulse_label, + previous_value=None, + ), + AnglesSchedules( + target_angle=np.pi / 2, + parameter="amp", + schedule="sx" + ef_pulse_label, + previous_value=None, + ), ] def _pre_circuit(self) -> QuantumCircuit: From 525d7db7c8e84e86385e2c9bb0b091fd07ee2463 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 28 Oct 2021 16:55:33 +0200 Subject: [PATCH 14/18] * Bug fix with options. --- .../library/calibration/rough_amplitude_cal.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index d85c96067f..59cb7b5a93 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -20,10 +20,11 @@ from qiskit.circuit import Parameter from qiskit.providers.backend import Backend -from qiskit_experiments.framework import ExperimentData +from qiskit_experiments.framework import ExperimentData, Options from qiskit_experiments.calibration_management import BaseCalibrationExperiment, BackendCalibrations from qiskit_experiments.library.characterization import Rabi from qiskit_experiments.calibration_management.update_library import BaseUpdater +from qiskit_experiments.curve_analysis import ParameterRepr AnglesSchedules = namedtuple( "AnglesSchedules", ["target_angle", "parameter", "schedule", "previous_value"] @@ -275,6 +276,14 @@ def __init__( ), ] + @classmethod + def _default_analysis_options(cls) -> Options: + """Default analysis options.""" + options = super()._default_analysis_options() + options.result_parameters = [ParameterRepr("freq", "rabi_rate_12")] + + return options + def _pre_circuit(self) -> QuantumCircuit: """A circuit with operations to perform before the Rabi.""" circ = QuantumCircuit(1) From 94a2870fff1dc768c5a455cdf4aa934b0aa27bbc Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Fri, 29 Oct 2021 11:02:47 +0200 Subject: [PATCH 15/18] * Test fix after merge main. --- test/calibration/experiments/test_rabi.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/calibration/experiments/test_rabi.py b/test/calibration/experiments/test_rabi.py index d868062395..c75a1203b7 100644 --- a/test/calibration/experiments/test_rabi.py +++ b/test/calibration/experiments/test_rabi.py @@ -99,7 +99,7 @@ def test_wrong_processor(self): def test_experiment_config(self): """Test converting to and from config works""" - exp = Rabi(0) + exp = Rabi(0, self.sched) config = exp.config loaded_exp = Rabi.from_config(config) self.assertNotEqual(exp, loaded_exp) @@ -164,7 +164,7 @@ def test_ef_rabi_circuit(self): def test_experiment_config(self): """Test converting to and from config works""" - exp = EFRabi(0) + exp = EFRabi(0, self.sched) config = exp.config loaded_exp = EFRabi.from_config(config) self.assertNotEqual(exp, loaded_exp) From b8bedd44a488dd543a745b25fc6f612e2d954855 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Fri, 29 Oct 2021 16:40:16 +0200 Subject: [PATCH 16/18] * setting of transpile options and the config test. --- .../library/calibration/rough_amplitude_cal.py | 2 +- test/calibration/experiments/test_rough_amplitude.py | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/qiskit_experiments/library/calibration/rough_amplitude_cal.py b/qiskit_experiments/library/calibration/rough_amplitude_cal.py index 332882a27c..9538425431 100644 --- a/qiskit_experiments/library/calibration/rough_amplitude_cal.py +++ b/qiskit_experiments/library/calibration/rough_amplitude_cal.py @@ -83,7 +83,7 @@ def __init__( ) # Needed for subclasses that will drive other transitions than the 0<->1 transition. - self.transpile_options.inst_map = calibrations.default_inst_map + self.set_transpile_options(inst_map=calibrations.default_inst_map) self._analysis_param_name = "rabi_rate" # Set the pulses to update. diff --git a/test/calibration/experiments/test_rough_amplitude.py b/test/calibration/experiments/test_rough_amplitude.py index f104e2f387..8bb3a58e90 100644 --- a/test/calibration/experiments/test_rough_amplitude.py +++ b/test/calibration/experiments/test_rough_amplitude.py @@ -66,6 +66,14 @@ def test_update(self): self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "x") - 0.333) < tol) self.assertTrue(abs(self.cals.get_parameter_value("amp", 0, "sx") - 0.333 / 2) < tol) + def test_experiment_config(self): + """Test converting to and from config works""" + exp = RoughXSXAmplitudeCal(0, self.cals) + config = exp.config + loaded_exp = RoughXSXAmplitudeCal.from_config(config) + self.assertNotEqual(exp, loaded_exp) + self.assertEqual(config, loaded_exp.config) + class TestSpecializations(QiskitTestCase): """Test the specialized versions of the calibration.""" From fd85d2bbb87e7a2e2e468d7d519e54e1b0e261d8 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Mon, 1 Nov 2021 18:16:14 +0100 Subject: [PATCH 17/18] Update qiskit_experiments/library/characterization/rabi.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/rabi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/rabi.py b/qiskit_experiments/library/characterization/rabi.py index 46007db1ed..761774ced7 100644 --- a/qiskit_experiments/library/characterization/rabi.py +++ b/qiskit_experiments/library/characterization/rabi.py @@ -51,7 +51,7 @@ class Rabi(BaseExperiment): See also `Qiskit Textbook `_ - for the pulse level programming of Rabi experiment. + for the pulse level programming of a Rabi experiment. """ From 9e6b769199d2cb57ec15a39473dccaba54eb8e1f Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Mon, 1 Nov 2021 18:16:34 +0100 Subject: [PATCH 18/18] Update docs/tutorials/calibrating_armonk.ipynb Co-authored-by: Will Shanks --- docs/tutorials/calibrating_armonk.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/calibrating_armonk.ipynb b/docs/tutorials/calibrating_armonk.ipynb index 6edf33b9b2..742412c9ee 100644 --- a/docs/tutorials/calibrating_armonk.ipynb +++ b/docs/tutorials/calibrating_armonk.ipynb @@ -629,7 +629,7 @@ "source": [ "## 2. Calibrating the pulse amplitudes with a Rabi experiment\n", "\n", - "In the Rabi experiment we apply a pulse at the frequency of the qubit and scan its amplitude to find the amplitude that creates a rotation of a desired angle. We do this with the calibration experiment `RoughXSXAmplitudeCal` this is a specialization of the `Rabi` experiment that will update the calibrations for both the `X` pulse and the `SX` pulse using a single experiment." + "In the Rabi experiment we apply a pulse at the frequency of the qubit and scan its amplitude to find the amplitude that creates a rotation of a desired angle. We do this with the calibration experiment `RoughXSXAmplitudeCal`. This is a specialization of the `Rabi` experiment that will update the calibrations for both the `X` pulse and the `SX` pulse using a single experiment." ] }, {