feat: Drop phase from flux protocols

Author: andrea-pasquale

src/qibocal/protocols/flux_dependence/qubit_crosstalk.py

@@ -70,9 +70,9 @@ class QubitCrosstalkData(QubitFluxData):
     )
     """Raw data acquired for (qubit, qubit_flux) pairs saved in nested dictionaries."""
 
-    def register_qubit(self, qubit, flux_qubit, freq, bias, signal, phase):
+    def register_qubit(self, qubit, flux_qubit, freq, bias, signal):
         """Store output for single qubit."""
-        ar = utils.create_data_array(freq, bias, signal, phase, dtype=QubitFluxType)
+        ar = utils.create_data_array(freq, bias, signal, dtype=QubitFluxType)
         if (qubit, flux_qubit) in self.data:
             self.data[qubit, flux_qubit] = np.rec.array(
                 np.concatenate((self.data[qubit, flux_qubit], ar))
@@ -120,10 +120,6 @@ def _acquisition(
     freq_sweepers = []
     offset_sweepers = []
 
-    delta_frequency_range = np.arange(
-        -params.freq_width / 2, params.freq_width / 2, params.freq_step
-    )
-
     for qubit in targets:
         natives = platform.natives.single_qubit[qubit]
         charging_energy[qubit] = platform.calibration.single_qubits[
@@ -159,21 +155,18 @@ def _acquisition(
         freq_sweepers.append(
             Sweeper(
                 parameter=Parameter.frequency,
-                values=platform.config(qd_channel).frequency + delta_frequency_range,
+                values=platform.config(qd_channel).frequency + params.frequency_range,
                 channels=[qd_channel],
             )
         )
 
-    delta_offset_range = np.arange(
-        -params.bias_width / 2, params.bias_width / 2, params.bias_step
-    )
     for q in params.flux_qubits:
         flux_channel = platform.qubits[q].flux
         offset0 = platform.config(flux_channel).offset
         offset_sweepers.append(
             Sweeper(
                 parameter=Parameter.offset,
-                values=offset0 + delta_offset_range,
+                values=offset0 + params.bais_range,
                 channels=[flux_channel],
             )
         )

src/qibocal/protocols/flux_dependence/qubit_flux_dependence.py

@@ -16,7 +16,7 @@
 from qibocal.auto.operation import Data, QubitId, Results, Routine
 from qibocal.calibration import CalibrationPlatform
 from qibocal.config import log
-from qibocal.result import magnitude, phase
+from qibocal.result import magnitude
 from qibocal.update import replace
 
 from ... import update
@@ -29,7 +29,6 @@
     table_html,
 )
 from . import utils
-from .resonator_flux_dependence import ResonatorFluxParameters
 
 __all__ = [
     "QubitFluxData",
@@ -41,7 +40,7 @@
 
 
 @dataclass
-class QubitFluxParameters(ResonatorFluxParameters):
+class QubitFluxParameters(utils.FluxFrequencySweepParameters):
     """QubitFlux runcard inputs."""
 
     drive_amplitude: Optional[float] = None
@@ -70,7 +69,6 @@ class QubitFluxResults(Results):
         ("freq", np.float64),
         ("bias", np.float64),
         ("signal", np.float64),
-        ("phase", np.float64),
     ]
 )
 """Custom dtype for resonator flux dependence."""
@@ -89,10 +87,10 @@ class QubitFluxData(Data):
     data: dict[QubitId, npt.NDArray[QubitFluxType]] = field(default_factory=dict)
     """Raw data acquired."""
 
-    def register_qubit(self, qubit, freq, bias, signal, phase):
+    def register_qubit(self, qubit, freq, bias, signal):
         """Store output for single qubit."""
         self.data[qubit] = utils.create_data_array(
-            freq, bias, signal, phase, dtype=QubitFluxType
+            freq, bias, signal, dtype=QubitFluxType
         )
 
     @property
@@ -117,13 +115,6 @@ def _acquisition(
 ) -> QubitFluxData:
     """Data acquisition for QubitFlux Experiment."""
 
-    delta_frequency_range = np.arange(
-        -params.freq_width / 2, params.freq_width / 2, params.freq_step
-    )
-    delta_offset_range = np.arange(
-        -params.bias_width / 2, params.bias_width / 2, params.bias_step
-    )
-
     sequence = PulseSequence()
     ro_pulses = {}
     qd_pulses = {}
@@ -151,7 +142,7 @@ def _acquisition(
         freq_sweepers.append(
             Sweeper(
                 parameter=Parameter.frequency,
-                values=frequency0 + delta_frequency_range,
+                values=frequency0 + params.frequency_range,
                 channels=[qd_channel],
             )
         )
@@ -161,7 +152,7 @@ def _acquisition(
         offset_sweepers.append(
             Sweeper(
                 parameter=Parameter.offset,
-                values=offset0 + delta_offset_range,
+                values=offset0 + params.bias_range,
                 channels=[flux_channel],
             )
         )
@@ -192,7 +183,6 @@ def _acquisition(
         data.register_qubit(
             qubit,
             signal=magnitude(result),
-            phase=phase(result),
             freq=freq_sweepers[i].values,
             bias=offset_sweepers[i].values,
         )

src/qibocal/protocols/flux_dependence/resonator_flux_dependence.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, field
-from typing import Optional
 
 import numpy as np
 import numpy.typing as npt
@@ -9,9 +8,9 @@
 from qibocal.calibration import CalibrationPlatform
 
 from ... import update
-from ...auto.operation import Data, Parameters, QubitId, Results, Routine
+from ...auto.operation import Data, QubitId, Results, Routine
 from ...config import log
-from ...result import magnitude, phase
+from ...result import magnitude
 from ..utils import (
     GHZ_TO_HZ,
     HZ_TO_GHZ,
@@ -26,18 +25,9 @@
 
 
 @dataclass
-class ResonatorFluxParameters(Parameters):
+class ResonatorFluxParameters(utils.FluxFrequencySweepParameters):
     """ResonatorFlux runcard inputs."""
 
-    freq_width: int
-    """Width for frequency sweep relative to the readout frequency [Hz]."""
-    freq_step: int
-    """Frequency step for sweep [Hz]."""
-    bias_width: Optional[float] = None
-    """Width for bias sweep [V]."""
-    bias_step: Optional[float] = None
-    """Bias step for sweep [a.u.]."""
-
 
 @dataclass
 class ResonatorFluxResults(Results):
@@ -61,7 +51,6 @@ class ResonatorFluxResults(Results):
         ("freq", np.float64),
         ("bias", np.float64),
         ("signal", np.float64),
-        ("phase", np.float64),
     ]
 )
 """Custom dtype for resonator flux dependence."""
@@ -82,10 +71,10 @@ class ResonatorFluxData(Data):
     data: dict[QubitId, npt.NDArray[ResFluxType]] = field(default_factory=dict)
     """Raw data acquired."""
 
-    def register_qubit(self, qubit, freq, bias, signal, phase):
+    def register_qubit(self, qubit, freq, bias, signal):
         """Store output for single qubit."""
         self.data[qubit] = utils.create_data_array(
-            freq, bias, signal, phase, dtype=ResFluxType
+            freq, bias, signal, dtype=ResFluxType
         )
 
     @property
@@ -110,12 +99,6 @@ def _acquisition(
 ) -> ResonatorFluxData:
     """Data acquisition for ResonatorFlux experiment."""
 
-    delta_frequency_range = np.arange(
-        -params.freq_width / 2, params.freq_width / 2, params.freq_step
-    )
-    delta_offset_range = np.arange(
-        -params.bias_width / 2, params.bias_width / 2, params.bias_step
-    )
     # taking advantage of multiplexing, apply the same set of gates to all qubits in parallel
     sequence = PulseSequence()
     ro_pulses = {}
@@ -137,14 +120,14 @@ def _acquisition(
         freq_sweepers.append(
             Sweeper(
                 parameter=Parameter.frequency,
-                values=readout_frequency(q, platform) + delta_frequency_range,
+                values=readout_frequency(q, platform) + params.frequency_range,
                 channels=[qubit.probe],
             )
         )
         offset_sweepers.append(
             Sweeper(
                 parameter=Parameter.offset,
-                values=offset0 + delta_offset_range,
+                values=offset0 + params.bias_range,
                 channels=[qubit.flux],
             )
         )
@@ -177,7 +160,6 @@ def _acquisition(
         data.register_qubit(
             qubit,
             signal=magnitude(result),
-            phase=phase(result),
             freq=freq_sweepers[i].values,
             bias=offset_sweepers[i].values,
         )

src/qibocal/protocols/flux_dependence/utils.py

@@ -1,24 +1,48 @@
+from dataclasses import dataclass
+
 import numpy as np
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
+from ...auto.operation import Parameters
 from ..utils import HZ_TO_GHZ
 
 
+@dataclass(kw_only=True)
+class FluxFrequencySweepParameters(Parameters):
+    """Parameters to define flux DC sweep."""
+
+    freq_width: int
+    """Width for frequency sweep relative to the readout frequency [Hz]."""
+    freq_step: int
+    """Frequency step for sweep [Hz]."""
+    bias_width: float
+    """Width for bias sweep [V]."""
+    bias_step: float
+    """Bias step for sweep [V]."""
+
+    @property
+    def frequency_range(self) -> np.ndarray:
+        return np.arange(-self.freq_width / 2, self.freq_width / 2, self.freq_step)
+
+    @property
+    def bias_range(self) -> np.ndarray:
+        return np.arange(-self.bias_width / 2, self.bias_width / 2, self.bias_step)
+
+
 def is_crosstalk(data):
     """Check if keys are tuple which corresponds to crosstalk data structure."""
     return all(isinstance(key, tuple) for key in data.data.keys())
 
 
-def create_data_array(freq, bias, signal, phase, dtype):
+def create_data_array(freq, bias, signal, dtype):
     """Create custom dtype array for acquired data."""
     size = len(freq) * len(bias)
     ar = np.empty(size, dtype=dtype)
     frequency, biases = np.meshgrid(freq, bias)
     ar["freq"] = frequency.ravel()
     ar["bias"] = biases.ravel()
     ar["signal"] = signal.ravel()
-    ar["phase"] = phase.ravel()
     return np.rec.array(ar)