refactor: Implement Juan suggestions

src/qibocal/protocols/characterization/flux_dependence/qubit_flux_dependence.py

@@ -16,7 +16,7 @@
     DEFAULT_ANHARMONICITY,
 )
 
-from ..utils import GHZ_TO_HZ, table_dict, table_html
+from ..utils import GHZ_TO_HZ, HZ_TO_GHZ, table_dict, table_html
 from . import utils
 
 
@@ -72,8 +72,11 @@ class QubitFluxResults(Results):
 class QubitFluxData(Data):
     """QubitFlux acquisition outputs."""
 
-    """Resonator type."""
     resonator_type: str
+    """Resonator type."""
+
+    qubit_frequency: dict[QubitId, float] = field(default_factory=dict)
+    """Qubit frequencies."""
 
     data: dict[QubitId, npt.NDArray[QubitFluxType]] = field(default_factory=dict)
     """Raw data acquired."""
@@ -96,10 +99,12 @@ def _acquisition(
     sequence = PulseSequence()
     ro_pulses = {}
     qd_pulses = {}
+    qubit_frequency = {}
     for qubit in qubits:
         qd_pulses[qubit] = platform.create_qubit_drive_pulse(
             qubit, start=0, duration=params.drive_duration
         )
+        qubit_frequency[qubit] = platform.qubits[qubit].drive_frequency
 
         if params.transition == "02":
             if qubits[qubit].anharmonicity:
@@ -138,7 +143,9 @@ def _acquisition(
             type=SweeperType.OFFSET,
         )
     ]
-    data = QubitFluxData(resonator_type=platform.resonator_type)
+    data = QubitFluxData(
+        resonator_type=platform.resonator_type, qubit_frequency=qubit_frequency
+    )
 
     options = ExecutionParameters(
         nshots=params.nshots,
@@ -159,7 +166,6 @@ def _acquisition(
                 freq=delta_frequency_range + qd_pulses[qubit].frequency,
                 bias=delta_bias_range + sweetspot,
             )
-
     return data
 
 
@@ -200,20 +206,9 @@ def _fit(data: QubitFluxData) -> QubitFluxResults:
         popt = curve_fit(
             utils.transmon_frequency,
             biases,
-            frequencies / 1e9,
-            bounds=(
-                [
-                    np.mean(qubit_data.freq) / 1e9 - 1,
-                    0,
-                    0,
-                    np.mean(qubit_data.bias) - 0.5,
-                ],
-                [
-                    np.mean(qubit_data.freq) / 1e9 + 1,
-                    1,
-                    np.inf,
-                    np.mean(qubit_data.bias) + 0.5,
-                ],
+            frequencies * HZ_TO_GHZ,
+            bounds=utils.qubit_flux_dependence_fit_bounds(
+                data.qubit_frequency[qubit], qubit_data.bias
             ),
             maxfev=100000,
         )[0]

src/qibocal/protocols/characterization/flux_dependence/qubit_flux_tracking.py

@@ -55,11 +55,12 @@ def _acquisition(
     sequence = PulseSequence()
     ro_pulses = {}
     qd_pulses = {}
+    qubit_frequency = {}
     for qubit in qubits:
         qd_pulses[qubit] = platform.create_qubit_drive_pulse(
             qubit, start=0, duration=params.drive_duration
         )
-
+        qubit_frequency[qubit] = platform.qubits[qubit].drive_frequency
         if params.transition == "02":
             if qubits[qubit].anharmonicity != 0:
                 qd_pulses[qubit].frequency -= qubits[qubit].anharmonicity / 2
@@ -91,7 +92,9 @@ def _acquisition(
         type=SweeperType.OFFSET,
     )
 
-    data = QubitFluxTrackData(resonator_type=platform.resonator_type)
+    data = QubitFluxTrackData(
+        resonator_type=platform.resonator_type, qubit_frequency=qubit_frequency
+    )
 
     for bias in delta_bias_range:
         for qubit in qubits:

src/qibocal/protocols/characterization/flux_dependence/resonator_flux_dependence.py

@@ -12,7 +12,7 @@
 from qibocal import update
 from qibocal.auto.operation import Data, Parameters, Qubits, Results, Routine
 
-from ..utils import GHZ_TO_HZ, table_dict, table_html
+from ..utils import GHZ_TO_HZ, HZ_TO_GHZ, table_dict, table_html
 from . import utils
 
 
@@ -100,6 +100,9 @@ def _acquisition(
     bare_resonator_frequency = {}
     for qubit in qubits:
         qubit_frequency[qubit] = platform.qubits[qubit].drive_frequency
+        bare_resonator_frequency[qubit] = platform.qubits[
+            qubit
+        ].bare_resonator_frequency
 
         ro_pulses[qubit] = platform.create_qubit_readout_pulse(qubit, start=0)
         sequence.add(ro_pulses[qubit])
@@ -128,7 +131,9 @@ def _acquisition(
     ]
 
     data = ResonatorFluxData(
-        resonator_type=platform.resonator_type, qubit_frequency=qubit_frequency
+        resonator_type=platform.resonator_type,
+        qubit_frequency=qubit_frequency,
+        bare_resonator_frequency=bare_resonator_frequency,
     )
 
     options = ExecutionParameters(
@@ -194,24 +199,11 @@ def _fit(data: ResonatorFluxData) -> ResonatorFluxResults:
         popt = curve_fit(
             utils.transmon_readout_frequency,
             biases,
-            frequencies / 1e9,
-            bounds=(
-                [
-                    data.qubit_frequency[qubit] / 1e9 - 0.5,
-                    0,
-                    0,
-                    np.mean(qubit_data.bias) - 0.5,
-                    np.mean(qubit_data.freq) / 1e9 - 1,
-                    0,
-                ],
-                [
-                    data.qubit_frequency[qubit] / 1e9 + 0.5,
-                    1,
-                    np.inf,
-                    np.mean(qubit_data.bias) + 0.5,
-                    np.mean(qubit_data.freq) / 1e9 + 1,
-                    1,
-                ],
+            frequencies * HZ_TO_GHZ,
+            bounds=utils.resonator_flux_dependence_fit_bounds(
+                data.qubit_frequency[qubit],
+                qubit_data.bias,
+                data.bare_resonator_frequency[qubit],
             ),
             maxfev=100000,
         )[0]