def load_virtual_gate_matrix_from_ds(ds_id, hardware_name):
'''
load virtual gate matrix from a existing dataset.
Args:
ds_id (int) : id of the dataset to load
hardware_name (str) : name of hardware in the snapshot present in the dataset
'''
load_virtual_gate_matrix_from_snapshot(load_by_id(ds_id).snapshot, hardware_name)
def load_AWG_to_dac_conversion_from_ds(ds_id, hardware_name):
'''
load AWG to dac conversion from a exisisting dataset.
Args:
ds_id (int) : id of the dataset to load
harware_name (str) : name of the hardware in the dataset its snapshow
'''
load_AWG_to_dac_conversion_from_snapshot(load_by_id(ds_id).snapshot, hardware_name)
# update plot every 300 ms for a smooth plotting experience
self.plot_layout.parentWidget().setUpdatesEnabled(True)
self.timer.timeout.connect(self.update_plots)
self.timer.start(300)
def update_plots(self):
if self.ds.completed == True:
self.timer.stop()
self.ds.sync()
for plot in self.plot_widgets:
try:
plot.update()
except:
logging.error(f'Plot update failed', exc_info=True)
if __name__ == '__main__':
from core_tools.data.SQL.connect import SQL_conn_info_local, SQL_conn_info_remote, sample_info, set_up_local_storage, set_up_remote_storage
from core_tools.data.ds.data_set import load_by_uuid, load_by_id
import sys
import datetime
# set_up_local_storage('stephan', 'magicc', 'test', 'Intel Project', 'F006', 'SQ38328342')
set_up_remote_storage('131.180.205.81', 5432, 'xld_measurement_pc',
'XLDspin001', 'spin_data', "6dot", "XLD",
"6D3S - SQ20-20-5-18-4")
ds = load_by_id(307)
p = data_plotter(ds)
# 'remote_usernam', 'remote_passwd', 'remote_dbname',
# 'project_name', 'set_up_name', 'sample_name')
# in case you are using both a local and remote server.
# set_up_local_and_remote_storage('ipaddr_rem_server', 5432,
# 'local_usernam', 'local_passwd', 'local_dbname',
# 'remote_usernam', 'remote_passwd', 'remote_dbname',
# 'project_name', 'set_up_name', 'sample_name')
# when you want to do sweeps
from core_tools.sweeps.sweeps import do0D, do1D, do2D
ds = do2D(param, start, stop, n_points, delay).run()
# see what is in the dataset
print(ds)
# inspecting data (extract arrays, labels, units):
x_data, y_data, z_data = ds.m1.x(), ds.m1.y(), ds.m1()
x_label, y_label, z_label = ds.m1.x.label, ds.m1.y.label, ds.m1.label
x_unit, y_unit, z_unit = ds.m1.x.unit, ds.m1.y.unit, ds.m1.unit
# when you want to plot a dataset
from core_tools.data.gui.plot_mgr import data_plotter
plot = data_plotter(ds)
# load a dataset by id or uuid
from core_tools.data.ds.data_set import load_by_id, load_by_uuid
ds = load_by_id(101)
from good_morning.fittings.fit_symmetry import fit_symmetry
if __name__ == '__main__':
from core_tools.data.SQL.connect import set_up_local_storage
set_up_local_storage("xld_user", "XLDspin001", "vandersypen_data", "6dot",
"XLD", "6D2S - SQ21-XX-X-XX-X")
from core_tools.data.ds.data_set import load_by_id
ds = load_by_id(16789)
x_axis = ds('read1').x()
y_axis = ds('read1').y()
probabilities = ds('read1').z()
fit_symmetry(x_axis, y_axis, probabilities, True)
line = QtWidgets.QFrame(self.geom_parent)
line.setFrameShape(QtWidgets.QFrame.HLine)
line.setFrameShadow(QtWidgets.QFrame.Sunken)
line.setObjectName(name)
return line
if __name__ == '__main__':
from core_tools.data.SQL.connector import SQL_conn_info_local, SQL_conn_info_remote, sample_info, set_up_local_storage
from core_tools.data.SQL.SQL_measurment_queries import query_for_measurement_results
from core_tools.data.ds.data_set import load_by_id
import sys
import datetime
set_up_local_storage('stephan', 'magicc', 'test', 'Intel Project', 'F006', 'SQ38328342')
ds = load_by_id(45782)
class test_window(QtWidgets.QMainWindow):
def __init__(self, MainWindow, ds):
super().__init__()
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.gridLayout_2 = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout_2.setObjectName("gridLayout_2")
self.scrollArea = QtWidgets.QScrollArea(self.centralwidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollArea.sizePolicy().hasHeightForWidth())
self.scrollArea.setSizePolicy(sizePolicy)
self.scrollArea.setMaximumSize(QtCore.QSize(800, 16777215))
Args:
frequency (np.ndarray) : GHz
probability (np.ndarray) : spin prob
'''
fit_result, confidence_interval = fit_resonance_raw(frequency, probability)
print(f'res freq = {round(fit_result.params["f_res"].value*1e-9, 6)} GHz')
if plot==True:
plt.figure()
plt.plot(frequency, probability, label='original data')
plt.plot(frequency, gauss_peak_function(fit_result.params, frequency), label='fitted data')
plt.xlabel('frequency (GHz)')
plt.ylabel(('spin probability (%)'))
plt.legend()
plt.show()
return fit_result.params['f_res'].value
if __name__ == '__main__':
from core_tools.data.SQL.connect import set_up_local_storage
set_up_local_storage("xld_user", "XLDspin001", "vandersypen_data", "6dot", "XLD", "6D2S - SQ21-XX-X-XX-X")
from core_tools.data.ds.data_set import load_by_id
ds = load_by_id(16728)
data = ds('read12')
print(data)
x = data.x()
y = data.y()
print(x, y)
fit_resonance(x, y, True)
intermedediate_result = mini.minimize(method='Nelder')
result = mini.minimize(method='leastsq', params=intermedediate_result.params)
best_fit = data + result.residual
if plot==True:
plt.figure()
plt.plot(data, 'bo')
plt.plot(best_fit, 'r--', label='best fit')
plt.xlabel('nth gate')
plt.ylabel('spin prob (%)')
plt.legend(loc='best')
plt.show()
# approximate errors.
print(f'Change pi time by {round(-result.params["rotation_error"].value/np.pi*100,2)} %')
print(f'Off resonant by {round(result.params["detuning_error"].value/time_pi_pulse*1e-6, 3)} MHz')
return -result.params["rotation_error"].value/np.pi, result.params["detuning_error"].value/time_pi_pulse/2
if __name__ == '__main__':
import numpy as np
from core_tools.data.SQL.connect import set_up_local_storage
set_up_local_storage("xld_user", "XLDspin001", "vandersypen_data", "6dot", "XLD", "6D2S - SQ21-XX-X-XX-X")
from core_tools.data.ds.data_set import load_by_id
ds = load_by_id(15996)
data = np.average(np.reshape(ds('read4').y(), (5, 21)), axis= 0)
a,b = fit_allXY(data, 300e-9, True)
print(a, b)
"6D3S - SQ20-20-5-18-4")
# ds = load_by_id(16949)
# data = ds('read5')
# fit_phase(data.x(), data.y(), False, True)
# ds = load_by_id(16947)
# data = ds('read1')
# fit_phase(data.x(), data.y(), False, True)
# ds = load_by_id(16948)
# data = ds('read2')
# fit_phase(data.x(), data.y(), True, True)
# ds = load_by_id(16950)
# data = ds('read4')
# fit_phase(data.x(), data.y(), True, True)
# ds = load_by_id(16949)
# data = ds('read5')
# fit_phase(data.x(), data.y(), False, True)
# ds = load_by_id(17046)
# data = ds('read4')
# fit_phase(data.x(), data.y(), True, True)
ds = load_by_id(17063)
data = ds('read2')
fit_phase(data.x(), data.y(), False, True)
# plt.show()
