diff --git a/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json b/src/cqedtoolbox/protocols/configs/parameter_manager-dummy_config.json index 68184dd..ea49414 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": 1.5 + }, + "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": 1.5 + }, + "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": 0 + }, + "parameter_manager.corrections.res_spec.sampling_factor": { + "unit": "", + "value": 2 + }, + "parameter_manager.corrections.res_spec.snr": { + "unit": "", + "value": 1.5 + }, + "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": 1.5 + }, + "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": 1.5 + }, + "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": 1.5 + }, + "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": 1.5 + }, + "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": 1.5 + }, "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 @@ -99,18 +335,18 @@ "unit": "", "value": 100 }, - "parameter_manager.qubit.end_f": { + "parameter_manager.qubit.f": { "unit": "Hz", - "value": 5010000000.0 - }, - "parameter_manager.qubit.start_f": { - "unit": "Hz", - "value": 4990000000.0 + "value": 5000000000.0 }, "parameter_manager.readout.end_g": { "unit": "", "value": 0.9 }, + "parameter_manager.readout.f": { + "unit": "Hz", + "value": 7000000000.0 + }, "parameter_manager.readout.gain": { "unit": "", "value": 0.58 @@ -119,6 +355,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 diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py index a597770..de3c0c9 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/pi_spec.py @@ -44,6 +44,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) + def _opx_getter(self): return self.params.corrections.pi_spec.snr() @@ -62,6 +68,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) + def _opx_getter(self): return self.params.corrections.pi_spec.max_fit_param_error() @@ -80,6 +92,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) + def _opx_getter(self): return self.params.corrections.pi_spec.averaging_factor() @@ -98,6 +116,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) + def _opx_getter(self): return int(self.params.corrections.pi_spec.max_averaging_increases()) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py b/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py index 23be70b..4219ba3 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/power_rabi.py @@ -43,6 +43,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) def _opx_getter(self): return self.params.corrections.power_rabi.snr() def _opx_setter(self, v): self.params.corrections.power_rabi.snr(v) @@ -54,6 +56,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) def _opx_getter(self): return self.params.corrections.power_rabi.max_fit_param_error() def _opx_setter(self, v): self.params.corrections.power_rabi.max_fit_param_error(v) @@ -65,6 +69,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) def _opx_getter(self): return self.params.corrections.power_rabi.averaging_factor() def _opx_setter(self, v): self.params.corrections.power_rabi.averaging_factor(v) @@ -76,6 +82,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) def _opx_getter(self): return int(self.params.corrections.power_rabi.max_averaging_increases()) def _opx_setter(self, v): self.params.corrections.power_rabi.max_averaging_increases(v) @@ -87,6 +95,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) def _opx_getter(self): return self.params.corrections.power_rabi.sampling_factor() def _opx_setter(self, v): self.params.corrections.power_rabi.sampling_factor(v) @@ -98,6 +108,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) def _opx_getter(self): return int(self.params.corrections.power_rabi.max_sampling_increases()) def _opx_setter(self, v): self.params.corrections.power_rabi.max_sampling_increases(v) @@ -109,6 +121,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) def _opx_getter(self): return self.params.corrections.power_rabi.delay_factor() def _opx_setter(self, v): self.params.corrections.power_rabi.delay_factor(v) @@ -120,6 +134,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) def _opx_getter(self): return int(self.params.corrections.power_rabi.max_delay_increases()) def _opx_setter(self, v): self.params.corrections.power_rabi.max_delay_increases(v) @@ -131,6 +147,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) def _opx_getter(self): return self.params.corrections.power_rabi.gain_shrink_factor() def _opx_setter(self, v): self.params.corrections.power_rabi.gain_shrink_factor(v) @@ -142,6 +160,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) def _opx_getter(self): return int(self.params.corrections.power_rabi.max_gain_shrinks()) def _opx_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 5b5b56b..8aa8f52 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, load_as_xr 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, nestedAttributeFromString) @@ -64,6 +65,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) + def _opx_getter(self): return self.params.corrections.res_spec.snr() @@ -81,6 +88,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) + def _opx_getter(self): return int(self.params.corrections.res_spec.max_window_shifts()) @@ -98,6 +111,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) + def _opx_getter(self): return self.params.corrections.res_spec.sampling_factor() @@ -115,6 +134,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) + def _opx_getter(self): return int(self.params.corrections.res_spec.max_sampling_increases()) @@ -132,6 +157,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) + def _opx_getter(self): return self.params.corrections.res_spec.averaging_factor() @@ -149,6 +180,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) + def _opx_getter(self): return int(self.params.corrections.res_spec.max_averaging_increases()) @@ -166,6 +203,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) + def _opx_getter(self): return self.params.corrections.res_spec.max_fit_param_error() @@ -294,7 +337,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 @@ -355,14 +398,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}" @@ -404,7 +450,7 @@ 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")) 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 89f9b1c..ef4551c 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 @@ -48,6 +48,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) + def _opx_getter(self): return self.params.corrections.res_spec_after_pi.snr() @@ -66,6 +72,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) + def _opx_getter(self): return self.params.corrections.res_spec_after_pi.max_fit_param_error() @@ -84,6 +96,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) + def _opx_getter(self): return self.params.corrections.res_spec_after_pi.detuning_threshold() 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 5dcf8e2..1afb090 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 @@ -43,6 +43,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) + def _opx_getter(self): return self.params.corrections.res_spec_vs_gain.snr() @@ -61,6 +67,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) + def _opx_getter(self): return self.params.corrections.res_spec_vs_gain.max_fit_param_error() @@ -79,6 +91,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) + def _opx_getter(self): return self.params.corrections.res_spec_vs_gain.high_snr() @@ -97,6 +115,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) + def _opx_getter(self): return self.params.corrections.res_spec_vs_gain.rep_factor() @@ -115,6 +139,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) + def _opx_getter(self): return int(self.params.corrections.res_spec_vs_gain.max_rep_increases()) diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py b/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py index b74cdc1..9bf8722 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/sat_spec.py @@ -47,6 +47,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) + def _opx_getter(self): return self.params.corrections.sat_spec.snr() @@ -65,6 +71,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) + def _opx_getter(self): return self.params.corrections.sat_spec.max_fit_param_error() @@ -83,6 +95,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) + def _opx_getter(self): return int(self.params.corrections.sat_spec.max_window_shifts()) @@ -101,6 +119,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) + def _opx_getter(self): return self.params.corrections.sat_spec.averaging_factor() @@ -119,6 +143,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) + def _opx_getter(self): return int(self.params.corrections.sat_spec.max_averaging_increases()) @@ -137,6 +167,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) + def _opx_getter(self): return self.params.corrections.sat_spec.sampling_factor() @@ -155,6 +191,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) + def _opx_getter(self): return int(self.params.corrections.sat_spec.max_sampling_increases()) @@ -173,6 +215,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) + def _opx_getter(self): return int(self.params.corrections.sat_spec.max_power_increases()) @@ -191,6 +239,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) + def _opx_getter(self): return self.params.corrections.sat_spec.power_increase_factor() @@ -209,6 +263,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) + def _opx_getter(self): return self.params.corrections.sat_spec.single_peak_snr() @@ -227,6 +287,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) + def _opx_getter(self): return int(self.params.corrections.sat_spec.single_peak_max_reductions()) @@ -245,6 +311,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) + def _opx_getter(self): return self.params.corrections.sat_spec.power_reduction_factor() diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t1.py b/src/cqedtoolbox/protocols/operations/single_qubit/t1.py index 253c2c5..519e069 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t1.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t1.py @@ -45,6 +45,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) def _opx_getter(self): return self.params.corrections.t1.snr_min() def _opx_setter(self, v): self.params.corrections.t1.snr_min(v) @@ -56,6 +58,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) def _opx_getter(self): return self.params.corrections.t1.max_fit_param_error() def _opx_setter(self, v): self.params.corrections.t1.max_fit_param_error(v) @@ -67,6 +71,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) def _opx_getter(self): return self.params.corrections.t1.delay_factor() def _opx_setter(self, v): self.params.corrections.t1.delay_factor(v) @@ -78,6 +84,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) def _opx_getter(self): return int(self.params.corrections.t1.max_delay_increases()) def _opx_setter(self, v): self.params.corrections.t1.max_delay_increases(v) @@ -89,6 +97,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) def _opx_getter(self): return self.params.corrections.t1.averaging_factor() def _opx_setter(self, v): self.params.corrections.t1.averaging_factor(v) @@ -100,6 +110,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) def _opx_getter(self): return int(self.params.corrections.t1.max_averaging_increases()) def _opx_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 7b8d79d..687ab61 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2e.py @@ -45,6 +45,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) def _opx_getter(self): return self.params.corrections.t2e.snr_min() def _opx_setter(self, v): self.params.corrections.t2e.snr_min(v) @@ -56,6 +58,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) def _opx_getter(self): return self.params.corrections.t2e.max_fit_param_error() def _opx_setter(self, v): self.params.corrections.t2e.max_fit_param_error(v) @@ -67,6 +71,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) def _opx_getter(self): return int(self.params.corrections.t2e.max_echos()) def _opx_setter(self, v): self.params.corrections.t2e.max_echos(v) @@ -78,6 +84,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) def _opx_getter(self): return self.params.corrections.t2e.averaging_factor() def _opx_setter(self, v): self.params.corrections.t2e.averaging_factor(v) @@ -89,6 +97,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) def _opx_getter(self): return int(self.params.corrections.t2e.max_averaging_increases()) def _opx_setter(self, v): self.params.corrections.t2e.max_averaging_increases(v) @@ -134,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 @@ -156,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 @@ -170,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__() @@ -200,7 +208,6 @@ def __init__(self, params): self._increase_averaging = IncreaseAveragingCorrection( self.repetitions, - self._increase_echos, self.averaging_increase_factor, self.max_averaging_increases, ) @@ -229,7 +236,7 @@ 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())) + + 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") diff --git a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py index e830a01..ad41944 100644 --- a/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py +++ b/src/cqedtoolbox/protocols/operations/single_qubit/t2r.py @@ -45,6 +45,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) def _opx_getter(self): return self.params.corrections.t2r.snr_min() def _opx_setter(self, v): self.params.corrections.t2r.snr_min(v) @@ -56,6 +58,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) def _opx_getter(self): return self.params.corrections.t2r.max_fit_param_error() def _opx_setter(self, v): self.params.corrections.t2r.max_fit_param_error(v) @@ -67,6 +71,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) def _opx_getter(self): return self.params.corrections.t2r.averaging_factor() def _opx_setter(self, v): self.params.corrections.t2r.averaging_factor(v) @@ -78,6 +84,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) def _opx_getter(self): return int(self.params.corrections.t2r.max_averaging_increases()) def _opx_setter(self, v): self.params.corrections.t2r.max_averaging_increases(v) @@ -124,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 + 0.4j def __init__(self, params): super().__init__() @@ -180,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") diff --git a/src/cqedtoolbox/protocols/parameters.py b/src/cqedtoolbox/protocols/parameters.py index 2f92fe6..5796a6d 100644 --- a/src/cqedtoolbox/protocols/parameters.py +++ b/src/cqedtoolbox/protocols/parameters.py @@ -488,6 +488,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) + def _opx_getter(self): q = nestedAttributeFromString(self.params, "active.qubit")() return nestedAttributeFromString(self.params, f"{q}.pulses.long.amp")()