idx
int64 0
7.85k
| idx_lca
int64 0
223
| offset
int64 162
55k
| repo
stringclasses 62
values | commit_hash
stringclasses 113
values | target_file
stringclasses 134
values | line_type_lca
stringclasses 7
values | ground_truth
stringlengths 1
46
| in_completions
bool 1
class | completion_type
stringclasses 6
values | non_dunder_count_intellij
int64 0
529
| non_dunder_count_jedi
int64 0
128
| start_with_
bool 2
classes | first_occurrence
bool 2
classes | intellij_completions
listlengths 1
532
| jedi_completions
listlengths 3
148
| prefix
stringlengths 162
55k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7,816 | 223 | 4,489 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
load_settings
| true |
function
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.
|
7,817 | 223 | 4,518 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
pl
| true |
statement
| 11 | 11 | false | false |
[
"mc",
"platform",
"run_t1",
"pl",
"run_resonator_spectroscopy",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"ins",
"load_settings",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.
|
7,818 | 223 | 6,259 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
lorentzian_fit
| true |
function
| 12 | 17 | false | false |
[
"t1_fit",
"rabi_fit",
"lorentzian_fit",
"ramsey_fit",
"curve_fit",
"BaseAnalysis",
"data_post",
"exp",
"rabi",
"ramsey",
"resonator_peak",
"set_datadir"
] |
[
{
"name": "BaseAnalysis",
"type": "module"
},
{
"name": "curve_fit",
"type": "module"
},
{
"name": "data_post",
"type": "function"
},
{
"name": "exp",
"type": "function"
},
{
"name": "lmfit",
"type": "module"
},
{
"name": "lorentzian_fit",
"type": "function"
},
{
"name": "np",
"type": "module"
},
{
"name": "os",
"type": "module"
},
{
"name": "pathlib",
"type": "module"
},
{
"name": "plt",
"type": "module"
},
{
"name": "rabi",
"type": "function"
},
{
"name": "rabi_fit",
"type": "function"
},
{
"name": "ramsey",
"type": "function"
},
{
"name": "ramsey_fit",
"type": "function"
},
{
"name": "resonator_peak",
"type": "function"
},
{
"name": "set_datadir",
"type": "module"
},
{
"name": "t1_fit",
"type": "function"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.
|
7,819 | 223 | 6,553 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
platform
| true |
statement
| 11 | 11 | false | false |
[
"platform",
"mc",
"load_settings",
"pl",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.
|
7,820 | 223 | 6,615 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
mc
| true |
statement
| 11 | 11 | false | false |
[
"mc",
"platform",
"load_settings",
"pl",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.
|
7,821 | 223 | 7,109 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.
|
7,822 | 223 | 7,140 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.
|
7,823 | 223 | 7,173 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
infile
|
load_settings
| true |
function
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.
|
7,824 | 223 | 7,202 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
pl
| true |
statement
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"run_t1",
"load_settings",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"ins",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.
|
7,825 | 223 | 8,038 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
rabi_fit
| true |
function
| 12 | 17 | false | true |
[
"t1_fit",
"lorentzian_fit",
"rabi",
"rabi_fit",
"ramsey_fit",
"BaseAnalysis",
"curve_fit",
"data_post",
"exp",
"ramsey",
"resonator_peak",
"set_datadir"
] |
[
{
"name": "BaseAnalysis",
"type": "module"
},
{
"name": "curve_fit",
"type": "module"
},
{
"name": "data_post",
"type": "function"
},
{
"name": "exp",
"type": "function"
},
{
"name": "lmfit",
"type": "module"
},
{
"name": "lorentzian_fit",
"type": "function"
},
{
"name": "np",
"type": "module"
},
{
"name": "os",
"type": "module"
},
{
"name": "pathlib",
"type": "module"
},
{
"name": "plt",
"type": "module"
},
{
"name": "rabi",
"type": "function"
},
{
"name": "rabi_fit",
"type": "function"
},
{
"name": "ramsey",
"type": "function"
},
{
"name": "ramsey_fit",
"type": "function"
},
{
"name": "resonator_peak",
"type": "function"
},
{
"name": "set_datadir",
"type": "module"
},
{
"name": "t1_fit",
"type": "function"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.
|
7,826 | 223 | 8,794 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
platform
| true |
statement
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.
|
7,827 | 223 | 8,856 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
mc
| true |
statement
| 11 | 11 | false | false |
[
"mc",
"platform",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.
|
7,828 | 223 | 9,446 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.
|
7,829 | 223 | 9,480 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.
|
7,830 | 223 | 9,513 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
load_settings
| true |
function
| 11 | 11 | false | false |
[
"mc",
"platform",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.
|
7,831 | 223 | 9,542 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
pl
| true |
statement
| 11 | 11 | false | false |
[
"mc",
"platform",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.
|
7,832 | 223 | 10,331 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
t1_fit
| true |
function
| 12 | 17 | false | true |
[
"lorentzian_fit",
"rabi_fit",
"t1_fit",
"ramsey_fit",
"curve_fit",
"BaseAnalysis",
"data_post",
"exp",
"rabi",
"ramsey",
"resonator_peak",
"set_datadir"
] |
[
{
"name": "BaseAnalysis",
"type": "module"
},
{
"name": "curve_fit",
"type": "module"
},
{
"name": "data_post",
"type": "function"
},
{
"name": "exp",
"type": "function"
},
{
"name": "lmfit",
"type": "module"
},
{
"name": "lorentzian_fit",
"type": "function"
},
{
"name": "np",
"type": "module"
},
{
"name": "os",
"type": "module"
},
{
"name": "pathlib",
"type": "module"
},
{
"name": "plt",
"type": "module"
},
{
"name": "rabi",
"type": "function"
},
{
"name": "rabi_fit",
"type": "function"
},
{
"name": "ramsey",
"type": "function"
},
{
"name": "ramsey_fit",
"type": "function"
},
{
"name": "resonator_peak",
"type": "function"
},
{
"name": "set_datadir",
"type": "module"
},
{
"name": "t1_fit",
"type": "function"
},
{
"name": "__doc__",
"type": "instance"
},
{
"name": "__file__",
"type": "instance"
},
{
"name": "__name__",
"type": "instance"
},
{
"name": "__package__",
"type": "instance"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.
|
7,833 | 223 | 10,542 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
platform
| true |
statement
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"load_settings",
"run_qubit_spectroscopy",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"ins",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.
|
7,834 | 223 | 11,252 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.
|
7,835 | 223 | 11,391 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
add
| true |
function
| 8 | 8 | false | false |
[
"add",
"pulses",
"phase",
"qcm_pulses",
"qrm_pulses",
"add_measurement",
"add_u3",
"time",
"__init__",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "add",
"type": "function"
},
{
"name": "add_measurement",
"type": "function"
},
{
"name": "add_u3",
"type": "function"
},
{
"name": "phase",
"type": "statement"
},
{
"name": "pulses",
"type": "statement"
},
{
"name": "qcm_pulses",
"type": "statement"
},
{
"name": "qrm_pulses",
"type": "statement"
},
{
"name": "time",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.
|
7,836 | 223 | 12,500 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
platform
| true |
statement
| 11 | 11 | false | false |
[
"platform",
"mc",
"pl",
"load_settings",
"callibrate_qubit_states",
"__init__",
"auto_calibrate_plaform",
"ins",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.
|
7,837 | 223 | 12,736 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
infile
|
run_resonator_spectroscopy
| true |
function
| 11 | 11 | false | true |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.
|
7,838 | 223 | 13,689 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
infile
|
run_qubit_spectroscopy
| true |
function
| 11 | 11 | false | true |
[
"platform",
"mc",
"pl",
"callibrate_qubit_states",
"load_settings",
"__init__",
"auto_calibrate_plaform",
"ins",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.
|
7,839 | 223 | 14,451 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
inproject
|
run_rabi_pulse_length
| true |
function
| 11 | 11 | false | true |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.
|
7,840 | 223 | 15,369 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
infile
|
callibrate_qubit_states
| true |
function
| 11 | 11 | false | true |
[
"platform",
"mc",
"pl",
"load_settings",
"ins",
"__init__",
"auto_calibrate_plaform",
"callibrate_qubit_states",
"run_qubit_spectroscopy",
"run_rabi_pulse_length",
"run_resonator_spectroscopy",
"run_t1",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "auto_calibrate_plaform",
"type": "function"
},
{
"name": "callibrate_qubit_states",
"type": "function"
},
{
"name": "ins",
"type": "statement"
},
{
"name": "load_settings",
"type": "function"
},
{
"name": "mc",
"type": "statement"
},
{
"name": "pl",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "run_qubit_spectroscopy",
"type": "function"
},
{
"name": "run_rabi_pulse_length",
"type": "function"
},
{
"name": "run_resonator_spectroscopy",
"type": "function"
},
{
"name": "run_t1",
"type": "function"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.
|
7,843 | 223 | 16,540 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
Unknown
|
qc_pulse
| true |
statement
| 6 | 6 | false | true |
[
"ro_pulse",
"qc_pulse",
"name",
"unit",
"label",
"__init__",
"set",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "qc_pulse",
"type": "statement"
},
{
"name": "ro_pulse",
"type": "statement"
},
{
"name": "set",
"type": "function"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.
|
7,844 | 223 | 16,579 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
common
|
ro_pulse
| true |
statement
| 6 | 6 | false | true |
[
"ro_pulse",
"qc_pulse",
"name",
"unit",
"label",
"__init__",
"set",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "qc_pulse",
"type": "statement"
},
{
"name": "ro_pulse",
"type": "statement"
},
{
"name": "set",
"type": "function"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.qc_pulse.duration = value
self.
|
7,848 | 223 | 17,001 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
common
|
ro_pulse
| true |
statement
| 7 | 7 | false | false |
[
"ro_pulse",
"name",
"unit",
"label",
"initial_value",
"__init__",
"base_duration",
"set",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "base_duration",
"type": "statement"
},
{
"name": "initial_value",
"type": "statement"
},
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "ro_pulse",
"type": "statement"
},
{
"name": "set",
"type": "function"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.qc_pulse.duration = value
self.ro_pulse.start = value + 4
class T1WaitParameter():
label = 'Time'
unit = 'ns'
name = 't1_wait'
initial_value = 0
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.base_duration = qc_pulse.duration
def set(self, value):
# TODO: implement following condition
#must be >= 4ns <= 65535
#platform.delay_before_readout = value
self.
|
7,850 | 223 | 17,023 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
common
|
base_duration
| true |
statement
| 7 | 7 | false | true |
[
"ro_pulse",
"base_duration",
"name",
"unit",
"label",
"__init__",
"initial_value",
"set",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "base_duration",
"type": "statement"
},
{
"name": "initial_value",
"type": "statement"
},
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "ro_pulse",
"type": "statement"
},
{
"name": "set",
"type": "function"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.qc_pulse.duration = value
self.ro_pulse.start = value + 4
class T1WaitParameter():
label = 'Time'
unit = 'ns'
name = 't1_wait'
initial_value = 0
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.base_duration = qc_pulse.duration
def set(self, value):
# TODO: implement following condition
#must be >= 4ns <= 65535
#platform.delay_before_readout = value
self.ro_pulse.start = self.
|
7,853 | 223 | 17,383 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
common
|
platform
| true |
statement
| 6 | 6 | false | false |
[
"platform",
"sequence",
"name",
"unit",
"label",
"__init__",
"get",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "get",
"type": "function"
},
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "sequence",
"type": "statement"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.qc_pulse.duration = value
self.ro_pulse.start = value + 4
class T1WaitParameter():
label = 'Time'
unit = 'ns'
name = 't1_wait'
initial_value = 0
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.base_duration = qc_pulse.duration
def set(self, value):
# TODO: implement following condition
#must be >= 4ns <= 65535
#platform.delay_before_readout = value
self.ro_pulse.start = self.base_duration + 4 + value
class ROController():
# Quantify Gettable Interface Implementation
label = ['Amplitude', 'Phase','I','Q']
unit = ['V', 'Radians','V','V']
name = ['A', 'Phi','I','Q']
def __init__(self, platform, sequence):
self.platform = platform
self.sequence = sequence
def get(self):
return self.
|
7,854 | 223 | 17,405 |
qiboteam__qibolab
|
e4b0e8e6dd612e696a161da9972f4bb9b6bf8cd0
|
src/qibolab/calibration/calibration.py
|
common
|
sequence
| true |
statement
| 6 | 6 | false | true |
[
"platform",
"sequence",
"name",
"unit",
"label",
"__init__",
"get",
"__annotations__",
"__class__",
"__delattr__",
"__dict__",
"__dir__",
"__eq__",
"__format__",
"__getattribute__",
"__hash__",
"__init_subclass__",
"__ne__",
"__new__",
"__reduce__",
"__reduce_ex__",
"__repr__",
"__setattr__",
"__sizeof__",
"__str__",
"__subclasshook__",
"__doc__",
"__module__"
] |
[
{
"name": "get",
"type": "function"
},
{
"name": "label",
"type": "statement"
},
{
"name": "name",
"type": "statement"
},
{
"name": "platform",
"type": "statement"
},
{
"name": "sequence",
"type": "statement"
},
{
"name": "unit",
"type": "statement"
},
{
"name": "__annotations__",
"type": "statement"
},
{
"name": "__class__",
"type": "property"
},
{
"name": "__delattr__",
"type": "function"
},
{
"name": "__dict__",
"type": "statement"
},
{
"name": "__dir__",
"type": "function"
},
{
"name": "__doc__",
"type": "statement"
},
{
"name": "__eq__",
"type": "function"
},
{
"name": "__format__",
"type": "function"
},
{
"name": "__getattribute__",
"type": "function"
},
{
"name": "__hash__",
"type": "function"
},
{
"name": "__init__",
"type": "function"
},
{
"name": "__init_subclass__",
"type": "function"
},
{
"name": "__module__",
"type": "statement"
},
{
"name": "__ne__",
"type": "function"
},
{
"name": "__new__",
"type": "function"
},
{
"name": "__reduce__",
"type": "function"
},
{
"name": "__reduce_ex__",
"type": "function"
},
{
"name": "__repr__",
"type": "function"
},
{
"name": "__setattr__",
"type": "function"
},
{
"name": "__sizeof__",
"type": "function"
},
{
"name": "__slots__",
"type": "statement"
},
{
"name": "__str__",
"type": "function"
}
] |
import pathlib
import numpy as np
#import matplotlib.pyplot as plt
import utils
import yaml
import fitting
from qibolab import Platform
# TODO: Have a look in the documentation of ``MeasurementControl``
#from quantify_core.measurement import MeasurementControl
from quantify_core.measurement.control import Gettable, Settable
from quantify_core.data.handling import set_datadir
from scipy.signal import savgol_filter
from qibolab.pulses import Pulse, ReadoutPulse
from qibolab.circuit import PulseSequence
from qibolab.pulse_shapes import Rectangular, Gaussian
# TODO: Check why this set_datadir is needed
#set_datadir(pathlib.Path("data") / "quantify")
set_datadir(pathlib.Path(__file__).parent / "data" / "quantify")
class Calibration():
def __init__(self, platform: Platform):
self.platform = platform
self.mc, self.pl, self.ins = utils.create_measurement_control('Calibration')
def load_settings(self):
# Load diagnostics settings
with open("calibration.yml", "r") as file:
return yaml.safe_load(file)
def run_resonator_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['resonator_spectroscopy']
lowres_width = ds['lowres_width']
lowres_step = ds['lowres_step']
highres_width = ds['highres_width']
highres_step = ds['highres_step']
precision_width = ds['precision_width']
precision_step = ds['precision_step']
#Fast Sweep
scanrange = utils.variable_resolution_scanrange(lowres_width, lowres_step, highres_width, highres_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Fast", soft_avg=1)
platform.stop()
platform.LO_qrm.set_frequency(dataset['x0'].values[dataset['y0'].argmax().values])
avg_min_voltage = np.mean(dataset['y0'].values[:(lowres_width//lowres_step)]) * 1e6
# Precision Sweep
scanrange = np.arange(-precision_width, precision_width, precision_step)
mc.settables(platform.LO_qrm.device.frequency)
mc.setpoints(scanrange + platform.LO_qrm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
platform.LO_qcm.off()
dataset = mc.run("Resonator Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 25, 2)
# resonator_freq = dataset['x0'].values[smooth_dataset.argmax()] + ro_pulse.frequency
max_ro_voltage = smooth_dataset.max() * 1e6
f0, BW, Q = fitting.lorentzian_fit("last", max, "Resonator_spectroscopy")
resonator_freq = (f0*1e9 + ro_pulse.frequency)
print(f"\nResonator Frequency = {resonator_freq}")
return resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset
def run_qubit_spectroscopy(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['qubit_spectroscopy']
fast_start = ds['fast_start']
fast_end = ds['fast_end']
fast_step = ds['fast_step']
precision_start = ds['precision_start']
precision_end = ds['precision_end']
precision_step = ds['precision_step']
# Fast Sweep
fast_sweep_scan_range = np.arange(fast_start, fast_end, fast_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(fast_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Fast", soft_avg=1)
platform.stop()
# Precision Sweep
platform.software_averages = 1
precision_sweep_scan_range = np.arange(precision_start, precision_end, precision_step)
mc.settables(platform.LO_qcm.device.frequency)
mc.setpoints(precision_sweep_scan_range + platform.LO_qcm.get_frequency())
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run("Qubit Spectroscopy Precision", soft_avg=software_averages)
platform.stop()
# Fitting
smooth_dataset = savgol_filter(dataset['y0'].values, 11, 2)
qubit_freq = dataset['x0'].values[smooth_dataset.argmin()] - qc_pulse.frequency
min_ro_voltage = smooth_dataset.min() * 1e6
print(f"\nQubit Frequency = {qubit_freq}")
utils.plot(smooth_dataset, dataset, "Qubit_Spectroscopy", 1)
print("Qubit freq ontained from MC results: ", qubit_freq)
f0, BW, Q = fitting.lorentzian_fit("last", min, "Qubit_Spectroscopy")
qubit_freq = (f0*1e9 - qc_pulse.frequency)
print("Qubit freq ontained from fitting: ", qubit_freq)
return qubit_freq, min_ro_voltage, smooth_dataset, dataset
def run_rabi_pulse_length(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
qc_pulse_shape = eval(ps['qc_spectroscopy_pulse'].popitem()[1])
qc_pulse_settings = ps['qc_spectroscopy_pulse']
qc_pulse = Pulse(**qc_pulse_settings, shape = qc_pulse_shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['rabi_pulse_length']
pulse_duration_start = ds['pulse_duration_start']
pulse_duration_end = ds['pulse_duration_end']
pulse_duration_step = ds['pulse_duration_step']
mc.settables(Settable(QCPulseLengthParameter(ro_pulse, qc_pulse)))
mc.setpoints(np.arange(pulse_duration_start, pulse_duration_end, pulse_duration_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('Rabi Pulse Length', soft_avg = software_averages)
platform.stop()
# Fitting
pi_pulse_amplitude = qc_pulse.amplitude
smooth_dataset, pi_pulse_duration, rabi_oscillations_pi_pulse_min_voltage, t1 = fitting.rabi_fit(dataset)
pi_pulse_gain = platform.qcm.gain
utils.plot(smooth_dataset, dataset, "Rabi_pulse_length", 1)
print(f"\nPi pulse duration = {pi_pulse_duration}")
print(f"\nPi pulse amplitude = {pi_pulse_amplitude}") #Check if the returned value from fitting is correct.
print(f"\nPi pulse gain = {pi_pulse_gain}") #Needed? It is equal to the QCM gain when performing a Rabi.
print(f"\nrabi oscillation min voltage = {rabi_oscillations_pi_pulse_min_voltage}")
print(f"\nT1 = {t1}")
return dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1
# T1: RX(pi) - wait t(rotates z) - readout
def run_t1(self):
platform = self.platform
platform.reload_settings()
mc = self.mc
ps = platform.settings['settings']
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
sequence = PulseSequence()
sequence.add(qc_pi_pulse)
sequence.add(ro_pulse)
ds = self.load_settings()
self.pl.tuids_max_num(ds['max_num_plots'])
software_averages = ds['software_averages']
ds = ds['t1']
delay_before_readout_start = ds['delay_before_readout_start']
delay_before_readout_end = ds['delay_before_readout_end']
delay_before_readout_step = ds['delay_before_readout_step']
mc.settables(Settable(T1WaitParameter(ro_pulse, qc_pi_pulse)))
mc.setpoints(np.arange(delay_before_readout_start,
delay_before_readout_end,
delay_before_readout_step))
mc.gettables(Gettable(ROController(platform, sequence)))
platform.start()
dataset = mc.run('T1', soft_avg = software_averages)
platform.stop()
# Fitting
smooth_dataset, t1 = fitting.t1_fit(dataset)
utils.plot(smooth_dataset, dataset, "t1", 1)
print(f'\nT1 = {t1}')
return t1, smooth_dataset, dataset
def callibrate_qubit_states(self):
platform = self.platform
platform.reload_settings()
ps = platform.settings['settings']
niter=10
nshots=1
#create exc and gnd pulses
start = 0
frequency = ps['pi_pulse_frequency']
amplitude = ps['pi_pulse_amplitude']
duration = ps['pi_pulse_duration']
phase = 0
shape = eval(ps['pi_pulse_shape'])
qc_pi_pulse = Pulse(start, duration, amplitude, frequency, phase, shape)
ro_pulse_shape = eval(ps['readout_pulse'].popitem()[1])
ro_pulse_settings = ps['readout_pulse']
ro_pulse = ReadoutPulse(**ro_pulse_settings, shape = ro_pulse_shape)
exc_sequence = PulseSequence()
exc_sequence.add(qc_pi_pulse)
gnd_sequence.add(ro_pulse)
gnd_sequence = PulseSequence()
#ro_pulse.start=0
gnd_sequence.add(ro_pulse)
platform.LO_qrm.set_frequency(ps['resonator_freq'] - ro_pulse.frequency)
platform.LO_qcm.set_frequency(ps['qubit_freq'] + qc_pi_pulse.frequency)
platform.start()
#Exectue niter single gnd shots
platform.LO_qcm.off()
all_gnd_states = []
for i in range(niter):
qubit_state = platform.execute(gnd_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_gnd_states.add(point)
#Exectue niter single exc shots
platform.LO_qcm.on()
all_exc_states = []
for i in range(niter):
qubit_state = platform.execute(exc_sequence, nshots)
#Compose complex point from i, q obtained from execution
point = complex(qubit_state[2], qubit_state[3])
all_exc_states.add(point)
platform.stop()
return all_gnd_states, np.mean(all_gnd_states), all_exc_states, np.mean(all_exc_states)
def auto_calibrate_plaform(self):
platform = self.platform
#backup latest platform runcard
utils.backup_config_file(platform)
#run and save cavity spectroscopy calibration
resonator_freq, avg_min_voltage, max_ro_voltage, smooth_dataset, dataset = self.run_resonator_spectroscopy()
print(utils.get_config_parameter("settings", "", "resonator_freq"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage"))
print(utils.get_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage"))
print(utils.get_config_parameter("LO_QRM_settings", "", "frequency"))
# utils.save_config_parameter("settings", "", "resonator_freq", float(resonator_freq))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_avg_min_ro_voltage", float(avg_min_voltage))
# utils.save_config_parameter("settings", "", "resonator_spectroscopy_max_ro_voltage", float(max_ro_voltage))
# utils.save_config_parameter("LO_QRM_settings", "", "frequency", float(resonator_freq - 20_000_000))
#run and save qubit spectroscopy calibration
qubit_freq, min_ro_voltage, smooth_dataset, dataset = self.run_qubit_spectroscopy()
print(utils.get_config_parameter("settings", "", "qubit_freq"))
print(utils.get_config_parameter("LO_QCM_settings", "", "frequency"))
print(utils.get_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage"))
# utils.save_config_parameter("settings", "", "qubit_freq", float(qubit_freq))
# utils.save_config_parameter("LO_QCM_settings", "", "frequency", float(qubit_freq + 200_000_000))
# utils.save_config_parameter("settings", "", "qubit_spectroscopy_min_ro_voltage", float(min_ro_voltage))
# #run Rabi and save Pi pulse params from calibration
dataset, pi_pulse_duration, pi_pulse_amplitude, pi_pulse_gain, rabi_oscillations_pi_pulse_min_voltage, t1 = self.run_rabi_pulse_length()
print(utils.get_config_parameter("settings", "", "pi_pulse_duration"))
print(utils.get_config_parameter("settings", "", "pi_pulse_amplitude"))
print(utils.get_config_parameter("settings", "", "pi_pulse_gain"))
print(utils.get_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage"))
# utils.save_config_parameter("settings", "", "pi_pulse_duration", int(pi_pulse_duration))
# utils.save_config_parameter("settings", "", "pi_pulse_amplitude", float(pi_pulse_amplitude))
# utils.save_config_parameter("settings", "", "pi_pulse_gain", float(pi_pulse_gain))
# utils.save_config_parameter("settings", "", "rabi_oscillations_pi_pulse_min_voltage", float(rabi_oscillations_pi_pulse_min_voltage))
# #run calibration_qubit_states
all_gnd_states, mean_gnd_states, all_exc_states, mean_exc_states = self.callibrate_qubit_states()
# #TODO: save in runcard mean_gnd_states and mean_exc_states
print(all_gnd_states)
print(mean_gnd_states)
print(all_exc_states)
print(mean_exc_states)
# #TODO: Remove plot qubit states results when tested
utils.plot_qubit_states(all_gnd_states, all_exc_states)
#TODO: Remove 0 and 1 classification from auto calibration when tested
#Classify all points into 0 and 1
classified_gnd_results = []
for point in all_gnd_states:
classified_gnd_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
classified_exc_results = []
for point in all_exc_states:
classified_exc_results.add(utils.classify(point, mean_gnd_states, mean_exc_states))
print(classified_gnd_results)
print(classified_exc_results)
# help classes
class QCPulseLengthParameter():
label = 'Qubit Control Pulse Length'
unit = 'ns'
name = 'qc_pulse_length'
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.qc_pulse = qc_pulse
def set(self, value):
self.qc_pulse.duration = value
self.ro_pulse.start = value + 4
class T1WaitParameter():
label = 'Time'
unit = 'ns'
name = 't1_wait'
initial_value = 0
def __init__(self, ro_pulse, qc_pulse):
self.ro_pulse = ro_pulse
self.base_duration = qc_pulse.duration
def set(self, value):
# TODO: implement following condition
#must be >= 4ns <= 65535
#platform.delay_before_readout = value
self.ro_pulse.start = self.base_duration + 4 + value
class ROController():
# Quantify Gettable Interface Implementation
label = ['Amplitude', 'Phase','I','Q']
unit = ['V', 'Radians','V','V']
name = ['A', 'Phi','I','Q']
def __init__(self, platform, sequence):
self.platform = platform
self.sequence = sequence
def get(self):
return self.platform.execute(self.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.