From 27a9d544b255dd907885945375e45e211908f58c Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Mon, 13 Jul 2026 23:28:08 -0500 Subject: [PATCH 01/11] adding dummy platform getter and setters to instantiate QubitTuneup from qubit_tuneup.py --- .../operations/single_qubit/pi_spec.py | 24 +++++++ .../operations/single_qubit/power_rabi.py | 20 ++++++ .../operations/single_qubit/res_spec.py | 50 ++++++++++++- .../single_qubit/res_spec_after_pi.py | 18 +++++ .../single_qubit/res_spec_vs_gain.py | 30 ++++++++ .../operations/single_qubit/sat_spec.py | 72 +++++++++++++++++++ .../protocols/operations/single_qubit/t1.py | 12 ++++ .../protocols/operations/single_qubit/t2e.py | 10 +++ .../protocols/operations/single_qubit/t2r.py | 8 +++ src/cqedtoolbox/protocols/parameters.py | 8 +++ 10 files changed, 251 insertions(+), 1 deletion(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py index 0d28af5..997a5be 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py @@ -43,6 +43,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.pi_spec.snr(value) + def _dummy_getter(self): + return self.params.corrections.pi_spec.snr() + + def _dummy_setter(self, value): + self.params.corrections.pi_spec.snr(value) + @dataclass class PiSpecMaxFitParamError(CorrectionParameter): @@ -55,6 +61,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.pi_spec.max_fit_param_error(value) + def _dummy_getter(self): + return self.params.corrections.pi_spec.max_fit_param_error() + + def _dummy_setter(self, value): + self.params.corrections.pi_spec.max_fit_param_error(value) + @dataclass class PiSpecAveragingFactor(CorrectionParameter): @@ -67,6 +79,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.pi_spec.averaging_factor(value) + def _dummy_getter(self): + return self.params.corrections.pi_spec.averaging_factor() + + def _dummy_setter(self, value): + self.params.corrections.pi_spec.averaging_factor(value) + @dataclass class PiSpecMaxAveragingIncreases(CorrectionParameter): @@ -79,6 +97,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.pi_spec.max_averaging_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.pi_spec.max_averaging_increases()) + + def _dummy_setter(self, value): + self.params.corrections.pi_spec.max_averaging_increases(value) + class IncreaseAveragingCorrection(Correction): name = "increase_averaging" diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py b/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py index 4bd5211..ac4f8fa 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py @@ -42,6 +42,8 @@ class SNRThreshold(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.snr() def _qick_setter(self, v): self.params.corrections.power_rabi.snr(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.snr() + def _dummy_setter(self, v): self.params.corrections.power_rabi.snr(v) @dataclass @@ -51,6 +53,8 @@ class MaxFitParamError(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.max_fit_param_error() def _qick_setter(self, v): self.params.corrections.power_rabi.max_fit_param_error(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.max_fit_param_error() + def _dummy_setter(self, v): self.params.corrections.power_rabi.max_fit_param_error(v) @dataclass @@ -60,6 +64,8 @@ class AveragingIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.averaging_factor() def _qick_setter(self, v): self.params.corrections.power_rabi.averaging_factor(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.averaging_factor() + def _dummy_setter(self, v): self.params.corrections.power_rabi.averaging_factor(v) @dataclass @@ -69,6 +75,8 @@ class MaxAveragingIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.power_rabi.max_averaging_increases()) def _qick_setter(self, v): self.params.corrections.power_rabi.max_averaging_increases(v) + def _dummy_getter(self): return int(self.params.corrections.power_rabi.max_averaging_increases()) + def _dummy_setter(self, v): self.params.corrections.power_rabi.max_averaging_increases(v) @dataclass @@ -78,6 +86,8 @@ class SamplingIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.sampling_factor() def _qick_setter(self, v): self.params.corrections.power_rabi.sampling_factor(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.sampling_factor() + def _dummy_setter(self, v): self.params.corrections.power_rabi.sampling_factor(v) @dataclass @@ -87,6 +97,8 @@ class MaxSamplingIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.power_rabi.max_sampling_increases()) def _qick_setter(self, v): self.params.corrections.power_rabi.max_sampling_increases(v) + def _dummy_getter(self): return int(self.params.corrections.power_rabi.max_sampling_increases()) + def _dummy_setter(self, v): self.params.corrections.power_rabi.max_sampling_increases(v) @dataclass @@ -96,6 +108,8 @@ class DelayIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.delay_factor() def _qick_setter(self, v): self.params.corrections.power_rabi.delay_factor(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.delay_factor() + def _dummy_setter(self, v): self.params.corrections.power_rabi.delay_factor(v) @dataclass @@ -105,6 +119,8 @@ class MaxDelayIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.power_rabi.max_delay_increases()) def _qick_setter(self, v): self.params.corrections.power_rabi.max_delay_increases(v) + def _dummy_getter(self): return int(self.params.corrections.power_rabi.max_delay_increases()) + def _dummy_setter(self, v): self.params.corrections.power_rabi.max_delay_increases(v) @dataclass @@ -114,6 +130,8 @@ class GainRangeShrinkFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.power_rabi.gain_shrink_factor() def _qick_setter(self, v): self.params.corrections.power_rabi.gain_shrink_factor(v) + def _dummy_getter(self): return self.params.corrections.power_rabi.gain_shrink_factor() + def _dummy_setter(self, v): self.params.corrections.power_rabi.gain_shrink_factor(v) @dataclass @@ -123,6 +141,8 @@ class MaxGainRangeShrinks(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.power_rabi.max_gain_shrinks()) def _qick_setter(self, v): self.params.corrections.power_rabi.max_gain_shrinks(v) + def _dummy_getter(self): return int(self.params.corrections.power_rabi.max_gain_shrinks()) + def _dummy_setter(self, v): self.params.corrections.power_rabi.max_gain_shrinks(v) # --------------------------------------------------------------------------- diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py index 383706e..54eb64a 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py @@ -63,6 +63,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.snr(value) + def _dummy_getter(self): + return self.params.corrections.res_spec.snr() + + def _dummy_setter(self, value): + self.params.corrections.res_spec.snr(value) + @dataclass class MaxWindowShifts(CorrectionParameter): @@ -75,6 +81,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.max_window_shifts(value) + def _dummy_getter(self): + return int(self.params.corrections.res_spec.max_window_shifts()) + + def _dummy_setter(self, value): + self.params.corrections.res_spec.max_window_shifts(value) + @dataclass class SamplingIncreaseFactor(CorrectionParameter): @@ -87,6 +99,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.sampling_factor(value) + def _dummy_getter(self): + return self.params.corrections.res_spec.sampling_factor() + + def _dummy_setter(self, value): + self.params.corrections.res_spec.sampling_factor(value) + @dataclass class MaxSamplingIncreases(CorrectionParameter): @@ -99,6 +117,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.max_sampling_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.res_spec.max_sampling_increases()) + + def _dummy_setter(self, value): + self.params.corrections.res_spec.max_sampling_increases(value) + @dataclass class AveragingIncreaseFactor(CorrectionParameter): @@ -111,6 +135,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.averaging_factor(value) + def _dummy_getter(self): + return self.params.corrections.res_spec.averaging_factor() + + def _dummy_setter(self, value): + self.params.corrections.res_spec.averaging_factor(value) + @dataclass class MaxAveragingIncreases(CorrectionParameter): @@ -123,6 +153,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.max_averaging_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.res_spec.max_averaging_increases()) + + def _dummy_setter(self, value): + self.params.corrections.res_spec.max_averaging_increases(value) + @dataclass class MaxFitParamError(CorrectionParameter): @@ -135,6 +171,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec.max_fit_param_error(value) + def _dummy_getter(self): + return self.params.corrections.res_spec.max_fit_param_error() + + def _dummy_setter(self, value): + self.params.corrections.res_spec.max_fit_param_error(value) + class WindowShiftCorrection(Correction): name = "window_shift" @@ -361,7 +403,13 @@ def _measure_dummy(self): noise_amp = self._SIM_NOISE_AMP ) - sweep = sweep_parameter("frequencies", frequencies + self.readout_lo(), record_as(generator.generate, "signal")) + sweep = sweep_parameter("frequencies", frequencies, record_as(generator.generate, "signal")) + # Removed "+ self.readout_lo()" after "frequencies" in above line, + # because it was causing AttributeError due to readout_lo not being registered, + # and deleting it is preferable to registering it because if we did register it, + # then it could get applied to all platforms, including qick, + # but qick may not have a readout_lo parameter, + # and it is not necessary for the dummy measurement anyway. loc, _ = run_and_save_sweep(sweep, "data", self.name) logger.info("Dummy measurement complete") diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_after_pi.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_after_pi.py index 88eea2d..fa7e5aa 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_after_pi.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_after_pi.py @@ -46,6 +46,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec_after_pi.snr(value) + def _dummy_getter(self): + return self.params.corrections.res_spec_after_pi.snr() + + def _dummy_setter(self, value): + self.params.corrections.res_spec_after_pi.snr(value) + @dataclass class ResSpecAfterPiMaxFitParamError(CorrectionParameter): @@ -58,6 +64,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec_after_pi.max_fit_param_error(value) + def _dummy_getter(self): + return self.params.corrections.res_spec_after_pi.max_fit_param_error() + + def _dummy_setter(self, value): + self.params.corrections.res_spec_after_pi.max_fit_param_error(value) + @dataclass class DetuningThreshold(CorrectionParameter): @@ -70,6 +82,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.res_spec_after_pi.detuning_threshold(value) + def _dummy_getter(self): + return self.params.corrections.res_spec_after_pi.detuning_threshold() + + def _dummy_setter(self, value): + self.params.corrections.res_spec_after_pi.detuning_threshold(value) + class ResonatorSpectroscopyAfterPi(ProtocolOperation): diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_vs_gain.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_vs_gain.py index 67335a2..54b4e6f 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_vs_gain.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec_vs_gain.py @@ -41,6 +41,12 @@ def _qick_getter(self): def _qick_setter(self, v): self.params.corrections.res_spec_vs_gain.snr(v) + def _dummy_getter(self): + return self.params.corrections.res_spec_vs_gain.snr() + + def _dummy_setter(self, v): + self.params.corrections.res_spec_vs_gain.snr(v) + @dataclass class ResSpecVsGainMaxFitParamError(CorrectionParameter): @@ -53,6 +59,12 @@ def _qick_getter(self): def _qick_setter(self, v): self.params.corrections.res_spec_vs_gain.max_fit_param_error(v) + def _dummy_getter(self): + return self.params.corrections.res_spec_vs_gain.max_fit_param_error() + + def _dummy_setter(self, v): + self.params.corrections.res_spec_vs_gain.max_fit_param_error(v) + @dataclass class ResSpecVsGainHighSNRThreshold(CorrectionParameter): @@ -65,6 +77,12 @@ def _qick_getter(self): def _qick_setter(self, v): self.params.corrections.res_spec_vs_gain.high_snr(v) + def _dummy_getter(self): + return self.params.corrections.res_spec_vs_gain.high_snr() + + def _dummy_setter(self, v): + self.params.corrections.res_spec_vs_gain.high_snr(v) + @dataclass class ResSpecVsGainRepetitionFactor(CorrectionParameter): @@ -77,6 +95,12 @@ def _qick_getter(self): def _qick_setter(self, v): self.params.corrections.res_spec_vs_gain.rep_factor(v) + def _dummy_getter(self): + return self.params.corrections.res_spec_vs_gain.rep_factor() + + def _dummy_setter(self, v): + self.params.corrections.res_spec_vs_gain.rep_factor(v) + @dataclass class ResSpecVsGainMaxRepetitionIncreases(CorrectionParameter): @@ -89,6 +113,12 @@ def _qick_getter(self): def _qick_setter(self, v): self.params.corrections.res_spec_vs_gain.max_rep_increases(v) + def _dummy_getter(self): + return int(self.params.corrections.res_spec_vs_gain.max_rep_increases()) + + def _dummy_setter(self, v): + self.params.corrections.res_spec_vs_gain.max_rep_increases(v) + class IncreaseRepetitionsCorrection(Correction): name = "increase_repetitions" diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py index 6abab81..a5b8658 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py @@ -46,6 +46,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.snr(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.snr() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.snr(value) + @dataclass class MaxFitParamError(CorrectionParameter): @@ -58,6 +64,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.max_fit_param_error(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.max_fit_param_error() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.max_fit_param_error(value) + @dataclass class MaxWindowShifts(CorrectionParameter): @@ -70,6 +82,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.max_window_shifts(value) + def _dummy_getter(self): + return int(self.params.corrections.sat_spec.max_window_shifts()) + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.max_window_shifts(value) + @dataclass class AveragingIncreaseFactor(CorrectionParameter): @@ -82,6 +100,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.averaging_factor(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.averaging_factor() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.averaging_factor(value) + @dataclass class MaxAveragingIncreases(CorrectionParameter): @@ -94,6 +118,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.max_averaging_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.sat_spec.max_averaging_increases()) + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.max_averaging_increases(value) + @dataclass class SamplingIncreaseFactor(CorrectionParameter): @@ -106,6 +136,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.sampling_factor(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.sampling_factor() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.sampling_factor(value) + @dataclass class MaxSamplingIncreases(CorrectionParameter): @@ -118,6 +154,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.max_sampling_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.sat_spec.max_sampling_increases()) + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.max_sampling_increases(value) + @dataclass class MaxPowerIncreases(CorrectionParameter): @@ -130,6 +172,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.max_power_increases(value) + def _dummy_getter(self): + return int(self.params.corrections.sat_spec.max_power_increases()) + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.max_power_increases(value) + @dataclass class PowerIncreaseFactor(CorrectionParameter): @@ -142,6 +190,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.power_increase_factor(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.power_increase_factor() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.power_increase_factor(value) + @dataclass class SinglePeakSNRThreshold(CorrectionParameter): @@ -154,6 +208,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.single_peak_snr(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.single_peak_snr() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.single_peak_snr(value) + @dataclass class SinglePeakMaxPowerReductions(CorrectionParameter): @@ -166,6 +226,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.single_peak_max_reductions(value) + def _dummy_getter(self): + return int(self.params.corrections.sat_spec.single_peak_max_reductions()) + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.single_peak_max_reductions(value) + @dataclass class PowerReductionFactor(CorrectionParameter): @@ -178,6 +244,12 @@ def _qick_getter(self): def _qick_setter(self, value): self.params.corrections.sat_spec.power_reduction_factor(value) + def _dummy_getter(self): + return self.params.corrections.sat_spec.power_reduction_factor() + + def _dummy_setter(self, value): + self.params.corrections.sat_spec.power_reduction_factor(value) + # --------------------------------------------------------------------------- # Correction strategies diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t1.py b/src/cqedtoolbox/protocols/operations/single_qubit/t1.py index 1c08201..7a4a070 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t1.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t1.py @@ -44,6 +44,8 @@ class SNRMinThreshold(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t1.snr_min() def _qick_setter(self, v): self.params.corrections.t1.snr_min(v) + def _dummy_getter(self): return self.params.corrections.t1.snr_min() + def _dummy_setter(self, v): self.params.corrections.t1.snr_min(v) @dataclass @@ -53,6 +55,8 @@ class MaxFitParamError(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t1.max_fit_param_error() def _qick_setter(self, v): self.params.corrections.t1.max_fit_param_error(v) + def _dummy_getter(self): return self.params.corrections.t1.max_fit_param_error() + def _dummy_setter(self, v): self.params.corrections.t1.max_fit_param_error(v) @dataclass @@ -62,6 +66,8 @@ class DelayIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t1.delay_factor() def _qick_setter(self, v): self.params.corrections.t1.delay_factor(v) + def _dummy_getter(self): return self.params.corrections.t1.delay_factor() + def _dummy_setter(self, v): self.params.corrections.t1.delay_factor(v) @dataclass @@ -71,6 +77,8 @@ class MaxDelayIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.t1.max_delay_increases()) def _qick_setter(self, v): self.params.corrections.t1.max_delay_increases(v) + def _dummy_getter(self): return int(self.params.corrections.t1.max_delay_increases()) + def _dummy_setter(self, v): self.params.corrections.t1.max_delay_increases(v) @dataclass @@ -80,6 +88,8 @@ class AveragingIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t1.averaging_factor() def _qick_setter(self, v): self.params.corrections.t1.averaging_factor(v) + def _dummy_getter(self): return self.params.corrections.t1.averaging_factor() + def _dummy_setter(self, v): self.params.corrections.t1.averaging_factor(v) @dataclass @@ -89,6 +99,8 @@ class MaxAveragingIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.t1.max_averaging_increases()) def _qick_setter(self, v): self.params.corrections.t1.max_averaging_increases(v) + def _dummy_getter(self): return int(self.params.corrections.t1.max_averaging_increases()) + def _dummy_setter(self, v): self.params.corrections.t1.max_averaging_increases(v) # --------------------------------------------------------------------------- diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py index 78772a1..5051993 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -44,6 +44,8 @@ class SNRMinThreshold(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2e.snr_min() def _qick_setter(self, v): self.params.corrections.t2e.snr_min(v) + def _dummy_getter(self): return self.params.corrections.t2e.snr_min() + def _dummy_setter(self, v): self.params.corrections.t2e.snr_min(v) @dataclass @@ -53,6 +55,8 @@ class MaxFitParamError(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2e.max_fit_param_error() def _qick_setter(self, v): self.params.corrections.t2e.max_fit_param_error(v) + def _dummy_getter(self): return self.params.corrections.t2e.max_fit_param_error() + def _dummy_setter(self, v): self.params.corrections.t2e.max_fit_param_error(v) @dataclass @@ -62,6 +66,8 @@ class MaxEchos(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.t2e.max_echos()) def _qick_setter(self, v): self.params.corrections.t2e.max_echos(v) + def _dummy_getter(self): return int(self.params.corrections.t2e.max_echos()) + def _dummy_setter(self, v): self.params.corrections.t2e.max_echos(v) @dataclass @@ -71,6 +77,8 @@ class AveragingIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2e.averaging_factor() def _qick_setter(self, v): self.params.corrections.t2e.averaging_factor(v) + def _dummy_getter(self): return self.params.corrections.t2e.averaging_factor() + def _dummy_setter(self, v): self.params.corrections.t2e.averaging_factor(v) @dataclass @@ -80,6 +88,8 @@ class MaxAveragingIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.t2e.max_averaging_increases()) def _qick_setter(self, v): self.params.corrections.t2e.max_averaging_increases(v) + def _dummy_getter(self): return int(self.params.corrections.t2e.max_averaging_increases()) + def _dummy_setter(self, v): self.params.corrections.t2e.max_averaging_increases(v) # --------------------------------------------------------------------------- diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py index 53204b8..ea10013 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py @@ -44,6 +44,8 @@ class SNRMinThreshold(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2r.snr_min() def _qick_setter(self, v): self.params.corrections.t2r.snr_min(v) + def _dummy_getter(self): return self.params.corrections.t2r.snr_min() + def _dummy_setter(self, v): self.params.corrections.t2r.snr_min(v) @dataclass @@ -53,6 +55,8 @@ class MaxFitParamError(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2r.max_fit_param_error() def _qick_setter(self, v): self.params.corrections.t2r.max_fit_param_error(v) + def _dummy_getter(self): return self.params.corrections.t2r.max_fit_param_error() + def _dummy_setter(self, v): self.params.corrections.t2r.max_fit_param_error(v) @dataclass @@ -62,6 +66,8 @@ class AveragingIncreaseFactor(CorrectionParameter): def _qick_getter(self): return self.params.corrections.t2r.averaging_factor() def _qick_setter(self, v): self.params.corrections.t2r.averaging_factor(v) + def _dummy_getter(self): return self.params.corrections.t2r.averaging_factor() + def _dummy_setter(self, v): self.params.corrections.t2r.averaging_factor(v) @dataclass @@ -71,6 +77,8 @@ class MaxAveragingIncreases(CorrectionParameter): def _qick_getter(self): return int(self.params.corrections.t2r.max_averaging_increases()) def _qick_setter(self, v): self.params.corrections.t2r.max_averaging_increases(v) + def _dummy_getter(self): return int(self.params.corrections.t2r.max_averaging_increases()) + def _dummy_setter(self, v): self.params.corrections.t2r.max_averaging_increases(v) # --------------------------------------------------------------------------- diff --git a/src/cqedtoolbox/protocols/parameters.py b/src/cqedtoolbox/protocols/parameters.py index 029347a..42a71ae 100644 --- a/src/cqedtoolbox/protocols/parameters.py +++ b/src/cqedtoolbox/protocols/parameters.py @@ -329,6 +329,14 @@ def _qick_setter(self, value): active_qubit = nestedAttributeFromString(self.params, "active.qubit")() return nestedAttributeFromString(self.params, f"{active_qubit}.pulses.const.gain")(value) + def _dummy_getter(self): + active_qubit = nestedAttributeFromString(self.params, "active.qubit")() + return nestedAttributeFromString(self.params, f"{active_qubit}.pulses.const.gain")() + + def _dummy_setter(self, value): + active_qubit = nestedAttributeFromString(self.params, "active.qubit")() + return nestedAttributeFromString(self.params, f"{active_qubit}.pulses.const.gain")(value) + @dataclass class StartQubitGain(ProtocolParameterBase): From 6b7513dce82073da2646f0b43cf5aa5655a628d8 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Tue, 14 Jul 2026 10:29:39 -0500 Subject: [PATCH 02/11] add dummy platform parameter json file for local working directory --- .../parameter_manager-dummy_config.json | 248 ++++++++++++++++++ 1 file changed, 248 insertions(+) diff --git a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json index 68184dd..78a12cc 100644 --- a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json +++ b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json @@ -3,6 +3,230 @@ "unit": "", "value": "q01" }, + "parameter_manager.corrections.pi_spec.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.pi_spec.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.pi_spec.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.pi_spec.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.power_rabi.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.delay_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.gain_shrink_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.max_delay_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.power_rabi.max_gain_shrinks": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.max_sampling_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.sampling_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.power_rabi.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.res_spec.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.max_fit_param_error": { + "unit": "", + "value": 1.0 + }, + "parameter_manager.corrections.res_spec.max_sampling_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.max_window_shifts": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.sampling_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.res_spec_after_pi.detuning_threshold": { + "unit": "MHz", + "value": 1.0 + }, + "parameter_manager.corrections.res_spec_after_pi.max_fit_param_error": { + "unit": "", + "value": 1.0 + }, + "parameter_manager.corrections.res_spec_after_pi.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.res_spec_vs_gain.high_snr": { + "unit": "", + "value": 10 + }, + "parameter_manager.corrections.res_spec_vs_gain.max_fit_param_error": { + "unit": "", + "value": 1.0 + }, + "parameter_manager.corrections.res_spec_vs_gain.max_rep_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec_vs_gain.rep_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec_vs_gain.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.sat_spec.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.sat_spec.max_power_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.max_sampling_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.max_window_shifts": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.power_increase_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.power_reduction_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.sampling_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.single_peak_max_reductions": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.sat_spec.single_peak_snr": { + "unit": "", + "value": 10 + }, + "parameter_manager.corrections.sat_spec.snr": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.t1.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t1.delay_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t1.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t1.max_delay_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t1.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.t1.snr_min": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.t2e.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t2e.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t2e.max_echos": { + "unit": "", + "value": 400 + }, + "parameter_manager.corrections.t2e.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.t2e.snr_min": { + "unit": "", + "value": 3 + }, + "parameter_manager.corrections.t2r.averaging_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t2r.max_averaging_increases": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.t2r.max_fit_param_error": { + "unit": "", + "value": 0.3 + }, + "parameter_manager.corrections.t2r.snr_min": { + "unit": "", + "value": 3 + }, "parameter_manager.msmt_params.delay": { "unit": "us", "value": 1.0 @@ -39,6 +263,14 @@ "unit": "", "value": 100 }, + "parameter_manager.q01.pi_spec_end": { + "unit": "Hz", + "value": 5010000000.0 + }, + "parameter_manager.q01.pi_spec_start": { + "unit": "Hz", + "value": 4990000000.0 + }, "parameter_manager.q01.pi_spec_steps": { "unit": "", "value": 300 @@ -51,6 +283,10 @@ "unit": "", "value": 0.0 }, + "parameter_manager.q01.pulses.const.gain": { + "unit": "", + "value": 0.2 + }, "parameter_manager.q01.pulses.pi.amp": { "unit": "", "value": 0.4991246743723084 @@ -103,6 +339,10 @@ "unit": "Hz", "value": 5010000000.0 }, + "parameter_manager.qubit.f": { + "unit": "Hz", + "value": 5000000000.0 + }, "parameter_manager.qubit.start_f": { "unit": "Hz", "value": 4990000000.0 @@ -111,6 +351,10 @@ "unit": "", "value": 0.9 }, + "parameter_manager.readout.f": { + "unit": "Hz", + "value": 7000000000.0 + }, "parameter_manager.readout.gain": { "unit": "", "value": 0.58 @@ -119,6 +363,10 @@ "unit": "us", "value": 1.0 }, + "parameter_manager.readout.resonator_spec_vs_gain_steps": { + "unit": "", + "value": 50 + }, "parameter_manager.readout.start_g": { "unit": "", "value": 0.1 From 2371ece166e63c8e1503ba878a8b9487a0e68af6 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Wed, 15 Jul 2026 11:40:52 -0500 Subject: [PATCH 03/11] relocating readoutLO comment to pr description --- .../protocols/operations/single_qubit/res_spec.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py index 54eb64a..f711f23 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py @@ -404,12 +404,6 @@ def _measure_dummy(self): ) sweep = sweep_parameter("frequencies", frequencies, record_as(generator.generate, "signal")) - # Removed "+ self.readout_lo()" after "frequencies" in above line, - # because it was causing AttributeError due to readout_lo not being registered, - # and deleting it is preferable to registering it because if we did register it, - # then it could get applied to all platforms, including qick, - # but qick may not have a readout_lo parameter, - # and it is not necessary for the dummy measurement anyway. loc, _ = run_and_save_sweep(sweep, "data", self.name) logger.info("Dummy measurement complete") From 4fb4215dfaa91920b9007b66d3f97af270f32931 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Thu, 16 Jul 2026 11:33:57 -0500 Subject: [PATCH 04/11] made res spec window shifting param zero and added helper in res spec py file to distinguish between qick MHz units and dummy Hz units to fix the resspecvsgain plot in html report --- .../configs/parameter_manager-dummy_config.json | 2 +- .../protocols/operations/single_qubit/res_spec.py | 10 +++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json index 78a12cc..be91e0f 100644 --- a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json +++ b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json @@ -77,7 +77,7 @@ }, "parameter_manager.corrections.res_spec.max_window_shifts": { "unit": "", - "value": 2 + "value": 0 }, "parameter_manager.corrections.res_spec.sampling_factor": { "unit": "", diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py index f711f23..b9e54df 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py @@ -11,8 +11,9 @@ from labcore.data.datadict_storage import datadict_from_hdf5 from labcore.measurement import sweep_parameter, record_as +from labcore.protocols import base as labcore_base from labcore.protocols.base import (ProtocolOperation, OperationStatus, serialize_fit_params, - ParamImprovement, CorrectionParameter, CheckResult, Correction) + ParamImprovement, CorrectionParameter, CheckResult, Correction, PlatformTypes) from cqedtoolbox.protocols.parameters import (Repetition, ResonatorSpecSteps, ReadoutGain, ReadoutLength, StartReadoutFrequency, EndReadoutFrequency, ReadoutFrequency) @@ -360,14 +361,17 @@ def __init__(self, params): lambda: self.fit_result.params["f_0"].value, ) + def _half_span(): + return 5 if labcore_base.PLATFORMTYPE == PlatformTypes.QICK else 5e6 + self._register_success_update( self.start_frequency, - lambda: self.fit_result.params["f_0"].value - 5, + lambda: self.fit_result.params["f_0"].value - _half_span(), ) self._register_success_update( self.end_frequency, - lambda: self.fit_result.params["f_0"].value + 5, + lambda: self.fit_result.params["f_0"].value + _half_span(), ) self.condition = f"Success if the SNR of the measurement is bigger than the current threshold of " # {self.SNR_THRESHOLD}" From 129b80266e368e252ed0e5362faed510ddd38d1e Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Thu, 16 Jul 2026 15:42:17 -0500 Subject: [PATCH 05/11] changed snr thresholds from 3 to 1.5 in dummy params json which helped sat spec plotting and also changed simphi from 0 to .4 to help res spec vs gain plotting --- .../configs/parameter_manager-dummy_config.json | 16 ++++++++-------- .../operations/single_qubit/res_spec.py | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json index be91e0f..8dcdc9e 100644 --- a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json +++ b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json @@ -17,7 +17,7 @@ }, "parameter_manager.corrections.pi_spec.snr": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.power_rabi.averaging_factor": { "unit": "", @@ -57,7 +57,7 @@ }, "parameter_manager.corrections.power_rabi.snr": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.res_spec.averaging_factor": { "unit": "", @@ -85,7 +85,7 @@ }, "parameter_manager.corrections.res_spec.snr": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.res_spec_after_pi.detuning_threshold": { "unit": "MHz", @@ -97,7 +97,7 @@ }, "parameter_manager.corrections.res_spec_after_pi.snr": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.res_spec_vs_gain.high_snr": { "unit": "", @@ -165,7 +165,7 @@ }, "parameter_manager.corrections.sat_spec.snr": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.t1.averaging_factor": { "unit": "", @@ -189,7 +189,7 @@ }, "parameter_manager.corrections.t1.snr_min": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.t2e.averaging_factor": { "unit": "", @@ -209,7 +209,7 @@ }, "parameter_manager.corrections.t2e.snr_min": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.corrections.t2r.averaging_factor": { "unit": "", @@ -225,7 +225,7 @@ }, "parameter_manager.corrections.t2r.snr_min": { "unit": "", - "value": 3 + "value": 1.5 }, "parameter_manager.msmt_params.delay": { "unit": "us", diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py index b9e54df..35618e2 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/res_spec.py @@ -301,7 +301,7 @@ class ResonatorSpectroscopy(ProtocolOperation): _SIM_QI = 20e3 _SIM_QC = 20e3 _SIM_A = 4.0 - _SIM_PHI = 0.0 + _SIM_PHI = 0.4 _SIM_NOISE_AMP = 0.05 From d144df1f0a965691b0a644a85836753fdb55ad6e Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Thu, 16 Jul 2026 18:21:12 -0500 Subject: [PATCH 06/11] merging changes from main may have deleted the increase echos here, which caused an attribute error when compiling the QubitTuneup html report because the parameter got deleted, so I am adding the increase echos back so the report can compile --- src/cqedtoolbox/protocols/operations/single_qubit/t2e.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py index ce4b775..718965e 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -208,6 +208,11 @@ def __init__(self, params): max_averaging_increases=MaxAveragingIncreases(params), ) + self._increase_echos = IncreaseEchosCorrection( + self.n_echos, + self.max_echos, + ) + self._increase_averaging = IncreaseAveragingCorrection( self.repetitions, self._increase_echos, From ab6f65ca2947f7fd1f2eab75d367c712ccd975d9 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Thu, 16 Jul 2026 18:46:19 -0500 Subject: [PATCH 07/11] removed additional instances of IncreaseEchosCorrection and related params because it shouldnt be included in t2e check --- .../protocols/operations/single_qubit/t2e.py | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py index 718965e..c4085cc 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -144,10 +144,8 @@ class IncreaseAveragingCorrection(Correction): description = "Increase number of repetitions and reset echo count" triggered_by = "quality_check" - def __init__(self, reps_param, echo_correction: IncreaseEchosCorrection, - factor_param, max_increases_param): + def __init__(self, reps_param, factor_param, max_increases_param): self.reps_param = reps_param - self.echo_correction = echo_correction self.factor_param = factor_param self.max_increases_param = max_increases_param self._original_reps: int | None = None @@ -166,7 +164,6 @@ def apply(self) -> None: self.reps_param(new) self._count += 1 self._last_change = f"reps: {old} → {new}" - self.echo_correction.reset() def report_output(self) -> str: return self._last_change @@ -208,14 +205,8 @@ def __init__(self, params): max_averaging_increases=MaxAveragingIncreases(params), ) - self._increase_echos = IncreaseEchosCorrection( - self.n_echos, - self.max_echos, - ) - self._increase_averaging = IncreaseAveragingCorrection( self.repetitions, - self._increase_echos, self.averaging_increase_factor, self.max_averaging_increases, ) From 9db47ac4a3cc2d2935a1d001b884b351c7355e82 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Thu, 16 Jul 2026 19:05:57 -0500 Subject: [PATCH 08/11] removed qubit.start_f and qubit.end_f from dummy param json because they aren't used --- .../protocols/configs/parameter_manager-dummy_config.json | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json index 8dcdc9e..ea49414 100644 --- a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json +++ b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json @@ -335,18 +335,10 @@ "unit": "", "value": 100 }, - "parameter_manager.qubit.end_f": { - "unit": "Hz", - "value": 5010000000.0 - }, "parameter_manager.qubit.f": { "unit": "Hz", "value": 5000000000.0 }, - "parameter_manager.qubit.start_f": { - "unit": "Hz", - "value": 4990000000.0 - }, "parameter_manager.readout.end_g": { "unit": "", "value": 0.9 From 1de9d190cdcb24dec5128631efeda214b80853a5 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Wed, 22 Jul 2026 12:09:33 -0500 Subject: [PATCH 09/11] added offset terms in t2r and t2e data generation, changed t2e analysis from exponentiallydecayingsine fit to exponentialdecay, these changes make the generated data and the fits more realistic as per equations 54 and 55 in PRXQuantum2040202 --- .../protocols/operations/single_qubit/t2e.py | 21 ++++++++++--------- .../protocols/operations/single_qubit/t2r.py | 4 ++-- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py index c4085cc..f66ebc4 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -8,7 +8,7 @@ plt.switch_backend("agg") from labcore.analysis import DatasetAnalysis -from labcore.analysis.fitfuncs.generic import ExponentiallyDecayingSine +from labcore.analysis.fitfuncs.generic import ExponentialDecay from labcore.measurement.storage import run_and_save_sweep from labcore.measurement.sweep import sweep_parameter from labcore.measurement.record import record_as @@ -177,8 +177,9 @@ class T2EOperation(ProtocolOperation): _SIM_T2E = 30.0 _SIM_DETUNING = 0.05 - _SIM_AMP = 0.5 + _SIM_AMP = 0.35 + 0.35j _SIM_NOISE_AMP = 0.02 + _SIM_OFFSET = 0.4 + 0.4j def __init__(self, params): super().__init__() @@ -234,8 +235,8 @@ def __init__(self, params): def _measure_dummy(self) -> Path: logger.info("Starting dummy T2 Echo measurement") delays = np.linspace(0, 5 * self._SIM_T2E, int(self.steps())) - signal_gen = lambda delays: (self._SIM_AMP * np.exp(-delays / self._SIM_T2E) * np.exp(2j * np.pi * self._SIM_DETUNING * delays) - + self._SIM_NOISE_AMP * (np.random.randn() + 1j * np.random.randn())) + signal_gen = lambda delays: (self._SIM_AMP * np.exp(-delays / self._SIM_T2E) + + self._SIM_OFFSET + self._SIM_NOISE_AMP * (np.random.randn() + 1j * np.random.randn())) sweep = sweep_parameter("delays", delays, record_as(signal_gen, "signal")) loc, _ = run_and_save_sweep(sweep, "data", self.name) logger.info("Dummy measurement complete") @@ -277,9 +278,9 @@ def _load_data_opx(self): self.independents["delays"] = data["delay"].values self.dependents["signal"] = data["signal_Re"].values + 1j * data["signal_Im"].values - def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title="") -> tuple: + def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tuple: """ - Fit real, imaginary, and magnitude components with ExponentiallyDecayingSine fits. + Fit real, imaginary, and magnitude components with ExponentialDecay fits. Returns (fit_result_re, fit_result_imag, fit_result_mag, fig_re, fig_imag, fig_mag) """ signal_re = signal.real @@ -287,7 +288,7 @@ def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title= signal_mag = np.abs(signal) # Fit real part - fit_re = ExponentiallyDecayingSine(delays, signal_re) + fit_re = ExponentialDecay(delays, signal_re) fit_result_re = fit_re.run(fit_re) fit_curve_re = fit_result_re.eval() residuals_re = signal_re - fit_curve_re @@ -296,7 +297,7 @@ def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title= snr_re = np.abs(amp_re / (4 * noise_re)) # Fit imaginary part - fit_imag = ExponentiallyDecayingSine(delays, signal_imag) + fit_imag = ExponentialDecay(delays, signal_imag) fit_result_imag = fit_imag.run(fit_imag) fit_curve_imag = fit_result_imag.eval() residuals_imag = signal_imag - fit_curve_imag @@ -305,7 +306,7 @@ def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title= snr_imag = np.abs(amp_imag / (4 * noise_imag)) # Fit magnitude - fit_mag = ExponentiallyDecayingSine(delays, signal_mag) + fit_mag = ExponentialDecay(delays, signal_mag) fit_result_mag = fit_mag.run(fit_mag) fit_curve_mag = fit_result_mag.eval() residuals_mag = signal_mag - fit_curve_mag @@ -349,7 +350,7 @@ def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title= def analyze(self): with DatasetAnalysis(self.data_loc, self.name) as ds: - result_re, result_imag, result_mag, fig_re, fig_imag, fig_mag = self._fit_exponentially_decaying_sine_components( + result_re, result_imag, result_mag, fig_re, fig_imag, fig_mag = self._fit_exponential_decay_components( self.independents["delays"], self.dependents["signal"], "T2 Echo Measurement" diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py index 2fe42fb..32ad0e9 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py @@ -134,7 +134,7 @@ class T2ROperation(ProtocolOperation): _SIM_DETUNING = 0.05 _SIM_AMP = 0.5 _SIM_NOISE_AMP = 0.02 - + _SIM_OFFSET = 0.4 def __init__(self, params): super().__init__() @@ -188,7 +188,7 @@ def _measure_dummy(self) -> Path: logger.info("Starting dummy T2 Ramsey measurement") delays = np.linspace(0, 5 * self._SIM_T2R, int(self.steps())) signal_gen = lambda delays: (self._SIM_AMP * np.exp(-delays / self._SIM_T2R) * np.exp(2j * np.pi * self._SIM_DETUNING * delays) - + self._SIM_NOISE_AMP * (np.random.randn() + 1j * np.random.randn())) + + self._SIM_OFFSET + self._SIM_NOISE_AMP * (np.random.randn() + 1j * np.random.randn())) sweep = sweep_parameter("delays", delays, record_as(signal_gen, "signal")) loc, _ = run_and_save_sweep(sweep, "data", self.name) logger.info("Dummy measurement complete") From 10b9c7cb9259f600e79c21210c959bd6c3d0f23f Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Wed, 22 Jul 2026 13:04:18 -0500 Subject: [PATCH 10/11] reverting t2e back to using ExponentiallyDecayingSine fitting because realized that OPX and Qick platforms existing fitting depends heavily on this type of fit, so added back in the oscillating term in the dummy data generation to keep this this artifical detuning part of the simulation --- .../protocols/operations/single_qubit/t2e.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py index f66ebc4..687ab61 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -8,7 +8,7 @@ plt.switch_backend("agg") from labcore.analysis import DatasetAnalysis -from labcore.analysis.fitfuncs.generic import ExponentialDecay +from labcore.analysis.fitfuncs.generic import ExponentiallyDecayingSine from labcore.measurement.storage import run_and_save_sweep from labcore.measurement.sweep import sweep_parameter from labcore.measurement.record import record_as @@ -235,7 +235,7 @@ def __init__(self, params): def _measure_dummy(self) -> Path: logger.info("Starting dummy T2 Echo measurement") delays = np.linspace(0, 5 * self._SIM_T2E, int(self.steps())) - signal_gen = lambda delays: (self._SIM_AMP * np.exp(-delays / self._SIM_T2E) + signal_gen = lambda delays: (self._SIM_AMP * np.exp(-delays / self._SIM_T2E) * np.exp(2j * np.pi * self._SIM_DETUNING * delays) + self._SIM_OFFSET + self._SIM_NOISE_AMP * (np.random.randn() + 1j * np.random.randn())) sweep = sweep_parameter("delays", delays, record_as(signal_gen, "signal")) loc, _ = run_and_save_sweep(sweep, "data", self.name) @@ -278,9 +278,9 @@ def _load_data_opx(self): self.independents["delays"] = data["delay"].values self.dependents["signal"] = data["signal_Re"].values + 1j * data["signal_Im"].values - def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tuple: + def _fit_exponentially_decaying_sine_components(self, delays, signal, fig_title="") -> tuple: """ - Fit real, imaginary, and magnitude components with ExponentialDecay fits. + Fit real, imaginary, and magnitude components with ExponentiallyDecayingSine fits. Returns (fit_result_re, fit_result_imag, fit_result_mag, fig_re, fig_imag, fig_mag) """ signal_re = signal.real @@ -288,7 +288,7 @@ def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tup signal_mag = np.abs(signal) # Fit real part - fit_re = ExponentialDecay(delays, signal_re) + fit_re = ExponentiallyDecayingSine(delays, signal_re) fit_result_re = fit_re.run(fit_re) fit_curve_re = fit_result_re.eval() residuals_re = signal_re - fit_curve_re @@ -297,7 +297,7 @@ def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tup snr_re = np.abs(amp_re / (4 * noise_re)) # Fit imaginary part - fit_imag = ExponentialDecay(delays, signal_imag) + fit_imag = ExponentiallyDecayingSine(delays, signal_imag) fit_result_imag = fit_imag.run(fit_imag) fit_curve_imag = fit_result_imag.eval() residuals_imag = signal_imag - fit_curve_imag @@ -306,7 +306,7 @@ def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tup snr_imag = np.abs(amp_imag / (4 * noise_imag)) # Fit magnitude - fit_mag = ExponentialDecay(delays, signal_mag) + fit_mag = ExponentiallyDecayingSine(delays, signal_mag) fit_result_mag = fit_mag.run(fit_mag) fit_curve_mag = fit_result_mag.eval() residuals_mag = signal_mag - fit_curve_mag @@ -350,7 +350,7 @@ def _fit_exponential_decay_components(self, delays, signal, fig_title="") -> tup def analyze(self): with DatasetAnalysis(self.data_loc, self.name) as ds: - result_re, result_imag, result_mag, fig_re, fig_imag, fig_mag = self._fit_exponential_decay_components( + result_re, result_imag, result_mag, fig_re, fig_imag, fig_mag = self._fit_exponentially_decaying_sine_components( self.independents["delays"], self.dependents["signal"], "T2 Echo Measurement" From 70f8778b7fa471f4f9c0776785c0cc5a719a62e6 Mon Sep 17 00:00:00 2001 From: al100-aleo Date: Wed, 22 Jul 2026 13:06:20 -0500 Subject: [PATCH 11/11] changed SIM_AMP and SIM_OFFSET in t2r to include imaginary components so that imaginary projections would make sense to have the imaginary fit be fitting to, now the t2r passes checks reliably --- src/cqedtoolbox/protocols/operations/single_qubit/t2r.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py index 32ad0e9..ad41944 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py @@ -132,9 +132,9 @@ class T2ROperation(ProtocolOperation): _SIM_T2R = 10.0 _SIM_DETUNING = 0.05 - _SIM_AMP = 0.5 + _SIM_AMP = 0.35 + 0.35j _SIM_NOISE_AMP = 0.02 - _SIM_OFFSET = 0.4 + _SIM_OFFSET = 0.4 + 0.4j def __init__(self, params): super().__init__()