def update_graph(clicks, selected_runs, selected_type, extra_runs, normalised,
data, selected_experiment):
if clicks is None:
raise PreventUpdate
if selected_experiment is None:
if selected_type is None:
return None, None, None, None
if selected_runs == []:
return dash.no_update, 'No Runs Selected!', dash.no_update, dash.no_update
if selected_runs is None:
return dash.no_update, 'No Runs Selected!', dash.no_update, dash.no_update
if selected_type is None:
return dash.no_update, 'No Data Type Selected!', dash.no_update, dash.no_update
for a in selected_runs:
params = str(load_by_id(a).parameters).split(',')
for b in dataNeeded[selected_type]:
if (b in params) is False:
return dash.no_update, 'Wrong Data Type!', dash.no_update, dash.no_update
total_runs = selected_runs
if extra_runs != None:
for c in extra_runs:
params_2 = str(load_by_id(c).parameters).split(',')
for d in dataNeeded[selected_type]:
if (d in params_2) is False:
return dash.no_update, dash.no_update, 'Wrong Run!', dash.no_update
total_runs = total_runs + extra_runs
totaldata = plot_data(selected_type, total_runs, normalised)
data['run'] = selected_runs
data['type'] = selected_type
data['extra-run'] = extra_runs
data['normalise'] = normalised
data['total-run'] = total_runs
data['graph'] = totaldata
return totaldata, None, None, data
def test_load_by_id():
ds = new_data_set("test-dataset")
run_id = ds.run_id
ds.mark_started()
ds.mark_completed()
loaded_ds = load_by_id(run_id)
assert ds.started is True
assert ds.pristine is False
assert ds.running is False
assert loaded_ds.completed is True
assert loaded_ds.exp_id == 1
ds = new_data_set("test-dataset-unfinished")
run_id = ds.run_id
loaded_ds = load_by_id(run_id)
assert ds.pristine is True
assert ds.running is False
assert ds.started is False
assert loaded_ds.completed is False
assert loaded_ds.exp_id == 1
# let's take a run number that is not in the temporary test database file
non_existing_run_id = run_id + 1
with pytest.raises(ValueError,
match=f"Run with run_id "
f"{non_existing_run_id} does not "
f"exist in the database"):
_ = load_by_id(non_existing_run_id)
def update_graph_live(n, tab, data, a_type, normalise, l_data):
if tab != 'tab-2':
raise PreventUpdate
if a_type is None:
raise PreventUpdate
if l_data is None:
raise PreventUpdate
live_run = exc.load_last_experiment().last_data_set().run_id
if data != None:
runs = data['runs']
runs.append(live_run)
else:
runs = [live_run]
if l_data != None:
for a in runs:
params = str(load_by_id(a).parameters).split(',')
for b in dataNeeded[l_data['type']]:
if (b in params) is False:
return dash.no_update, 'Wrong Data Type!'
graph = plot_data(l_data['type'], runs, l_data['normalise'])
else:
for a in runs:
params = str(load_by_id(a).parameters).split(',')
for b in dataNeeded[a_type]:
if (b in params) is False:
return dash.no_update, 'Wrong Data Type!'
graph = plot_data(a_type, runs, normalise)
return graph, None
def diff_param_values_by_id(left_id : RunId, right_id : RunId):
"""
Given the IDs of two datasets, returns the differences between
parameter values in each of their snapshots.
"""
# Local import to reduce load time and
# avoid circular references.
from qcodes.dataset.data_set import load_by_id
return diff_param_values(
load_by_id(left_id).snapshot,
load_by_id(right_id).snapshot
)
def test_load_by_id():
ds = new_data_set("test-dataset")
run_id = ds.run_id
ds.mark_complete()
loaded_ds = load_by_id(run_id)
assert loaded_ds.completed is True
assert loaded_ds.exp_id == 1
ds = new_data_set("test-dataset-unfinished")
run_id = ds.run_id
loaded_ds = load_by_id(run_id)
assert loaded_ds.completed is False
assert loaded_ds.exp_id == 1
def get_data_by_id(run_id: int) -> List:
"""
Load data from database and reshapes into 1D arrays with minimal
name, unit and label metadata.
"""
data = load_by_id(run_id)
conn = data.conn
deps = get_dependents(conn, run_id)
output = []
for dep in deps:
dependencies = get_dependencies(conn, dep)
data_axis = get_layout(conn, dep)
rawdata = data.get_values(data_axis['name'])
data_axis['data'] = flatten_1D_data_for_plot(rawdata)
raw_setpoint_data = data.get_setpoints(data_axis['name'])
my_output = []
for i, dependency in enumerate(dependencies):
axis = get_layout(conn, dependency[0])
axis['data'] = flatten_1D_data_for_plot(raw_setpoint_data[i])
my_output.append(axis)
my_output.append(data_axis)
output.append(my_output)
return output
def calculate_tunneling_rate(runids, station=None, exp=None, plot=False):
meas = Measurement(exp=exp, station=station)
meas.register_parameter(station.n6705b.VTUN, )
meas.register_custom_parameter("Tunneling_Gradient",
setpoints=(station.n6705b.VTUN, ),
unit="V/S")
meas.register_custom_parameter("runid")
grads = []
tun_vs = []
for id in runids:
data = load_by_id(id)
sweep_data = data.get_parameter_data()
x = sweep_data['dmm_VOUT']['time']
y = sweep_data['dmm_VOUT']['dmm_VOUT']
tun_v = sweep_data['n6705b_VTUN']['n6705b_VTUN'][0]
# y = mx + b
m, b = polyfit(x, y, 1)
grads.append(m)
tun_vs.append(tun_v)
if plot:
plt.figure()
plt.plot(x, y)
y2 = x * m + b
plt.plot(x, y2)
plt.ylabel("vout [V]")
plt.xlabel("time [s]")
plt.show()
with meas.run() as datasaver:
for m, tv, run in zip(grads, tun_vs, runids):
datasaver.add_result((station.n6705b.VTUN, tv),
("Tunneling_Gradient", m), ("runid", run))
def plot_by_id(run_id: int,
axes: Optional[Union[matplotlib.axes.Axes,
Sequence[matplotlib.axes.Axes]]] = None,
colorbars: Optional[Union[matplotlib.colorbar.Colorbar,
Sequence[
matplotlib.colorbar.Colorbar]]] = None,
rescale_axes: bool = True,
auto_color_scale: Optional[bool] = None,
cutoff_percentile: Optional[Union[Tuple[Number, Number],
Number]] = None,
complex_plot_type: str = 'real_and_imag',
complex_plot_phase: str = 'radians',
**kwargs) -> AxesTupleList:
"""
Construct all plots for a given `run_id`. All other arguments are forwarded
to :func:`.plot_dataset`, see this for more details.
"""
dataset = load_by_id(run_id)
return plot_dataset(dataset,
axes,
colorbars,
rescale_axes,
auto_color_scale,
cutoff_percentile,
complex_plot_type,
complex_plot_phase,
**kwargs)
def leakage_sweep(voltage_out,
dmm,
to=1e-3,
nump=101,
wt=0.1,
ithaco_impedance=20):
id, plot = qcm.linear1d(voltage_out.voltage,
0,
to,
nump,
wt,
dmm.ithaco_current,
setback=True)
data = load_by_id(id)
plot.close()
yoko_param = voltage_out.voltage.full_name
dmm_param = dmm.ithaco_current.full_name
setpoints = np.array(data.get_data(yoko_param)).T[0]
values = np.array(data.get_data(dmm_param)).T[0]
fit, res, _, _, _ = np.polyfit(values, setpoints, 1, full=True)
fit[0] = abs(fit[0])
print("Resistance was: {}Ohms".format(
si_prefix.si_format(fit[0] - ithaco_impedance, precision=3)))
print("Residuals were: {}".format(res))
return fit, res
def test_load_by_X_functions(two_empty_temp_db_connections, some_interdeps):
"""
Test some different loading functions
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp1 = Experiment(conn=source_conn)
source_ds_1_1 = DataSet(conn=source_conn, exp_id=source_exp1.exp_id)
source_exp2 = Experiment(conn=source_conn)
source_ds_2_1 = DataSet(conn=source_conn, exp_id=source_exp2.exp_id)
source_ds_2_2 = DataSet(conn=source_conn,
exp_id=source_exp2.exp_id,
name="customname")
for ds in (source_ds_1_1, source_ds_2_1, source_ds_2_2):
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
ds.add_result({name: 0.0 for name in some_interdeps[1].names})
ds.mark_completed()
extract_runs_into_db(source_path, target_path, source_ds_2_2.run_id)
test_ds = load_by_guid(source_ds_2_2.guid, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_id(1, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_counter(1, 1, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
def plot_landau_fan():
dataset = 1035
dataset = load_by_id(dataset)
param_data = dataset.get_parameter_data("R_xx", "R_xy")
voltage_data = param_data["R_xx"]["yoko_voltage"]
field_data = param_data["R_xx"]["mag_GRPZ_field"]
R_xx_data = param_data["R_xx"]["R_xx"]
R_xy_data = param_data["R_xy"]["R_xy"]
# Reshape data
lvoltage_data, voltage_data = np.array(detect_cycle(voltage_data))
field_data = np.array(field_data[::lvoltage_data])
y, x = np.mgrid[slice(voltage_data[0], voltage_data[-1], complex(0, lvoltage_data+1)),
slice(field_data[0], field_data[-1], complex(0, field_data.size))]
R_xx_data = R_xx_data.reshape((field_data.size, lvoltage_data)).T
R_xy_data = R_xy_data.reshape((field_data.size, lvoltage_data)).T
vk_const = const.value("von Klitzing constant")
fig, ax1 = plt.subplots()
im = ax1.pcolormesh(y, x, np.log10(R_xx_data), vmin=1, vmax=5, cmap="inferno", rasterized=True)
fig.colorbar(im)
ax1.set_xlabel(r"Gate Voltage $\left(\si{\volt}\right)$")
ax1.set_ylabel(r"$\textrm{B}_{\perp}$ $\left(\si{\tesla}\right)$")
fig.tight_layout()
fig.show()
fig, ax1 = plt.subplots()
ax1.pcolormesh(y, x, vk_const/R_xy_data, vmin=2, vmax=32, cmap="cividis_r")
ax1.set_xlabel(r"Gate Voltage $\left(\si{\volt}\right)$")
ax1.set_ylabel(r"$\textrm{B}_{\perp}$ $\left(\si{\tesla}\right)$")
fig.tight_layout()
fig.show()
def data_sets(self) -> List[DataSet]:
"""Get all the datasets of this experiment"""
runs = get_runs(self.conn, self.exp_id)
data_sets = []
for run in runs:
data_sets.append(load_by_id(run['run_id'], conn=self.conn))
return data_sets
def get_snapshot(data_id):
"""
Get a snapshot from the dataset indexed by data_id
"""
data = load_by_id(data_id)
snap_str = data.get_metadata('snapshot')
snap = json.loads(snap_str)
return snap
def load_dataset_from(path: str, run_id: int) -> 'DataSet':
"""
Loads ``DataSet`` with the given ``run_id`` from a database file that
is located in in the given ``path``.
Note that after the call to this function, the database location in the
qcodes config of the current python process is changed to ``path``.
"""
initialise_or_create_database_at(path)
return load_by_id(run_id=run_id)
def diff_param_values_by_id(left_id: RunId, right_id: RunId) -> ParameterDiff:
"""
Given the IDs of two datasets, returns the differences between
parameter values in each of their snapshots.
"""
# Local import to reduce load time and
# avoid circular references.
from qcodes.dataset.data_set import load_by_id
left_snapshot = load_by_id(left_id).snapshot
right_snapshot = load_by_id(right_id).snapshot
if left_snapshot is None or right_snapshot is None:
if left_snapshot is None:
empty = left_id
else:
empty = right_id
raise RuntimeError(f"Tried to compare two snapshots"
f"but the snapshot of {empty} "
f"is empty.")
return diff_param_values(left_snapshot, right_snapshot)
def test_perform_actual_upgrade_6_to_7():
fixpath = os.path.join(fixturepath, 'db_files', 'version6')
db_file = 'some_runs.db'
dbname_old = os.path.join(fixpath, db_file)
if not os.path.exists(dbname_old):
pytest.skip("No db-file fixtures found. You can generate test db-files"
" using the scripts in the "
"https://github.com/QCoDeS/qcodes_generate_test_db/ repo")
with temporarily_copied_DB(dbname_old, debug=False, version=6) as conn:
assert isinstance(conn, ConnectionPlus)
perform_db_upgrade_6_to_7(conn)
assert get_user_version(conn) == 7
no_of_runs_query = "SELECT max(run_id) FROM runs"
no_of_runs = one(atomic_transaction(conn, no_of_runs_query),
'max(run_id)')
assert no_of_runs == 10
columns = atomic_transaction(conn,
"PRAGMA table_info(runs)").fetchall()
col_names = [col['name'] for col in columns]
assert 'captured_run_id' in col_names
assert 'captured_counter' in col_names
for run_id in range(1, no_of_runs + 1):
ds1 = load_by_id(run_id, conn)
ds2 = load_by_run_spec(captured_run_id=run_id, conn=conn)
assert ds1.the_same_dataset_as(ds2)
assert ds1.run_id == run_id
assert ds1.run_id == ds1.captured_run_id
assert ds2.run_id == run_id
assert ds2.run_id == ds2.captured_run_id
exp_id = 1
for counter in range(1, no_of_runs + 1):
ds1 = load_by_counter(counter, exp_id, conn)
ds2 = load_by_run_spec(captured_counter=counter, conn=conn)
assert ds1.the_same_dataset_as(ds2)
assert ds1.counter == counter
assert ds1.counter == ds1.captured_counter
assert ds2.counter == counter
assert ds2.counter == ds2.captured_counter
def export_by_id(run_id):
'''Export CSV files with raw data of a measurement run.'''
dataset = load_by_id(run_id)
data = []
headers = []
for parameter_name, specs in dataset.paramspecs.items():
parameter_data = np.ravel(dataset.get_data(parameter_name))
data.append(parameter_data)
parameter_header = '{} ({})'.format(specs.label, specs.unit)
headers.append(parameter_header)
data = np.vstack(data).T
header = ' '.join(headers)
filename = get_export_path(run_id, dataset.exp_id)
np.savetxt(filename, data, header=header)
def plot_hall_sweep_hmob():
datasets = (1054, 1055, 1056, 1057, 1058)
field_data = np.zeros(0)
R_xx_data = np.zeros(0)
R_xy_data = np.zeros(0)
for dataset in datasets:
dataset = load_by_id(dataset)
param_data = dataset.get_parameter_data("R_xx", "R_xy")
field_data = np.append(field_data, param_data["R_xx"]["mag_GRPZ_field"])
R_xx_data = np.append(R_xx_data, param_data["R_xx"]["R_xx"])
R_xy_data = np.append(R_xy_data, param_data["R_xy"]["R_xy"])
max_x, min_x = np.where(field_data > 7.2)[0][0], np.where(field_data > 6.6)[0][0]
print(min_x, max_x)
print(f"Rho_XY (nu = 6) = {np.average(R_xy_data[min_x:max_x])}")
smallfield = np.where(field_data > 0.05)[0][0]
print(smallfield)
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(field_data, R_xy_data, 'b-', label="Rxy")
ax2.plot(field_data, R_xx_data, 'r-', label="Rxx")
# Plot plateaus
vk_const = const.value("von Klitzing constant")
for i in range(6, 12+1, 2):
ax1.axhline(vk_const/i)
print(f"At (nu = {i}): {vk_const/i:.2f}")
# Plot theoretical locations
density = np.polyfit(field_data[:500], R_xy_data[:500], 1)
print(f"Fitting to field: {field_data[500]}.")
density = 1/(const.e * density[0])
print(f"Extracted Density: {density*1e-4:e} cm^2/Vs")
filling_factors = (2*const.pi*density*const.hbar)/(const.e)
for i in range(6, 12+1, 2):
ax1.axvline(filling_factors/i)
print(R_xx_data[11])
sq = 1 / 5 # Width / length
mu = 1/(np.average(R_xx_data[11-2:11+3]) * sq * const.e * density * 1e-4)
print(f"Extracted Mobility: {mu}")
fig.legend()
ax1.set_xlabel(r"Field $\left(\si{\tesla}\right)$")
ax1.set_ylabel(r"$\textrm{R}_{xy}$ $\left(\si{\ohm}\right)$")
ax2.set_ylabel(r"$\textrm{R}_{xx}$ $\left(\si{\ohm}\right)$")
fig.tight_layout()
fig.show()
def __init__(self, *args, id, refresh=1):
super().__init__(*args)
self.id = id
alldata = get_data_by_id(self.id)
self.nplots = len(alldata)
# initiate plots
for i, data in enumerate(alldata):
x = data[0]
y = data[1]
if len(data) == 2: # 1D PLOTTING
po = self._add_1d(i, x, y)
elif len(data) == 3: # 2D PLOTTING
z = data[2]
po = self._add_2d(i, x, y, z)
# add subscriber
#dataset = load_by_id(self.id)
#dataset.subscribe(self.update_from_subscriber, min_wait=0, min_count=1, state=[])
dataset = load_by_id(self.id)
self.completed = dataset.completed
while not self.completed:
dataset = load_by_id(self.id)
self.completed = dataset.completed
self.update_plots()
time.sleep(refresh)
def test_load_by_X_functions(two_empty_temp_db_connections,
some_interdeps):
"""
Test some different loading functions
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp1 = Experiment(conn=source_conn)
source_ds_1_1 = DataSet(conn=source_conn, exp_id=source_exp1.exp_id)
source_exp2 = Experiment(conn=source_conn)
source_ds_2_1 = DataSet(conn=source_conn, exp_id=source_exp2.exp_id)
source_ds_2_2 = DataSet(conn=source_conn,
exp_id=source_exp2.exp_id,
name="customname")
for ds in (source_ds_1_1, source_ds_2_1, source_ds_2_2):
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
ds.add_results([{name: 0.0 for name in some_interdeps[1].names}])
ds.mark_completed()
extract_runs_into_db(source_path, target_path, source_ds_2_2.run_id)
extract_runs_into_db(source_path, target_path, source_ds_2_1.run_id)
extract_runs_into_db(source_path, target_path, source_ds_1_1.run_id)
test_ds = load_by_guid(source_ds_2_2.guid, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_id(1, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_run_spec(captured_run_id=source_ds_2_2.captured_run_id,
conn=target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
assert source_exp2.exp_id == 2
# this is now the first run in the db so run_id is 1
target_run_id = 1
# and the experiment ids will be interchanged.
target_exp_id = 1
test_ds = load_by_counter(target_run_id, target_exp_id, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
def comparator_sweep(exp, station, fn_switch, voltages, values=None):
"""
open loop sweep of vref
"""
# Set the switch state to 'open'
if not callable(fn_switch):
raise ValueError("Expecting Switch Function")
fn_switch("open")
deps = [station.dmm.VOUT]
indeps = [
station.n6705b.VBUS, station.n6705b.VFEEDBACK, station.n6705b.VREF,
station.n6705b.VTUN, station.b2962.VDD, station.b2962.VDRAIN,
station.yoko.VBIAS, station.b2962.ch1.current,
station.b2962.ch2.current
]
if values is None:
values = np.linspace(0, voltages['vdd'], 101)
# Sweep VFEEDBACK
# runid = linear_trace(indeps, deps, station.n6705b.VFEEDBACK,
# np.linspace(0, voltages['vdd'], 101), delay=0.5,
# exp=exp, station=station,
# fn_before=lambda: setup(station, voltages),
# fn_after=lambda: all_disable(station))
# # determine trip voltage
# # pull "dmm_volt" and "n6705b_VFEEDBACK" out of dataset
# data = load_by_id(runid)
# sweep_data = data.get_parameter_data()
# trip_point = find_trip_voltage(sweep_data['dmm_VOUT']['n6705b_VFEEDBACK'],
# sweep_data['dmm_VOUT']['dmm_VOUT'])
# Determine a good vref
# voltages['vfeedback'] = trip_point
runid = linear_trace(indeps,
deps,
station.n6705b.VREF,
values,
delay=0.5,
exp=exp,
station=station,
fn_before=lambda: setup(station, voltages),
fn_after=lambda: all_disable(station))
data = load_by_id(runid)
sweep_data = data.get_parameter_data()
vref_point = find_vref(sweep_data['dmm_VOUT']['n6705b_VREF'],
sweep_data['dmm_VOUT']['dmm_VOUT'])
return (vref_point, runid)
def test_load_by_X_functions(two_empty_temp_db_connections, some_paramspecs):
"""
Test some different loading functions
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp1 = Experiment(conn=source_conn)
source_ds_1_1 = DataSet(conn=source_conn, exp_id=source_exp1.exp_id)
for ps in some_paramspecs[2].values():
source_ds_1_1.add_parameter(ps)
source_ds_1_1.mark_started()
source_ds_1_1.add_result(
{ps.name: 0.0
for ps in some_paramspecs[2].values()})
source_ds_1_1.mark_completed()
source_exp2 = Experiment(conn=source_conn)
source_ds_2_1 = DataSet(conn=source_conn, exp_id=source_exp2.exp_id)
for ps in some_paramspecs[2].values():
source_ds_2_1.add_parameter(ps)
source_ds_2_1.mark_started()
source_ds_2_1.add_result(
{ps.name: 0.0
for ps in some_paramspecs[2].values()})
source_ds_2_1.mark_completed()
source_ds_2_2 = DataSet(conn=source_conn,
exp_id=source_exp2.exp_id,
name="customname")
for ps in some_paramspecs[2].values():
source_ds_2_2.add_parameter(ps)
source_ds_2_2.mark_started()
source_ds_2_2.add_result(
{ps.name: 0.0
for ps in some_paramspecs[2].values()})
source_ds_2_2.mark_completed()
extract_runs_into_db(source_path, target_path, source_ds_2_2.run_id)
test_ds = load_by_guid(source_ds_2_2.guid, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_id(1, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
test_ds = load_by_counter(1, 1, target_conn)
assert source_ds_2_2.the_same_dataset_as(test_ds)
def plot_hall_sweep_lmob():
datasets = (1045,)
field_data = np.zeros(0)
R_xx_data = np.zeros(0)
R_xy_data = np.zeros(0)
for dataset in datasets:
dataset = load_by_id(dataset)
param_data = dataset.get_parameter_data("R_xx", "R_xy")
field_data = np.append(field_data, param_data["R_xx"]["mag_GRPZ_field"])
R_xx_data = np.append(R_xx_data, param_data["R_xx"]["R_xx"])
R_xy_data = np.append(R_xy_data, param_data["R_xy"]["R_xy"])
field_data = field_data[:-100]
R_xx_data = R_xx_data[:-100]
R_xy_data = R_xy_data[:-100]
field_data = 1/field_data
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(field_data, R_xy_data, 'b-', label="Rxy")
ax2.plot(field_data, R_xx_data, 'r-', label="Rxx")
res, _ = curve_fit(dec_sin, field_data, R_xx_data, (2000, 5000, 150, -1, 1))
print(res)
ax2.plot(field_data, dec_sin(field_data, *res), 'k--')
# # Plot plateaus
# vk_const = const.value("von Klitzing constant")
# for i in range(12, 24+1, 2):
# ax1.axhline(vk_const/i)
#
# # Plot theoretical locations
# density = np.polyfit(field_data[-100:], R_xy_data[-100:], 1)
# print(f"Fitting to field: {field_data[-100]}.")
# density = 1/(const.e * density[0])
# print(f"Extracted Density: {density*1e-4:e} cm^2/Vs")
# filling_factors = (2*const.pi*density*const.hbar)/(const.e)
# for i in range(12, 24+1, 2):
# ax1.axvline(filling_factors/i)
fig.legend()
ax1.set_xlabel(r"1/Field $\left(\si{\per\tesla}\right)$")
ax1.set_ylabel(r"$\textrm{R}_{xy}$ $\left(\si{\ohm}\right)$")
ax2.set_ylabel(r"$\textrm{R}_{xx}$ $\left(\si{\ohm}\right)$")
fig.tight_layout()
fig.show()
def get_data_by_id(run_id: int) -> \
List[List[Dict[str, Union[str, np.ndarray]]]]:
"""
Load data from database and reshapes into 1D arrays with minimal
name, unit and label metadata.
Only returns data from parameters that depend on other parameters or
parameters that other parameters depend on, i.e. data for standalone
parameters are not returned.
Args:
run_id: run ID from the database
Returns:
a list of lists of dictionaries like this:
::
[
# each element in this list refers
# to one dependent (aka measured) parameter
[
# each element in this list refers
# to one independent (aka setpoint) parameter
# that the dependent parameter depends on;
# a dictionary with the data and metadata of the dependent
# parameter is in the *last* element in this list
...
{
'data': <1D numpy array of points>,
'name': <name of the parameter>,
'label': <label of the parameter or ''>,
'unit': <unit of the parameter or ''>
},
...
],
...
]
"""
ds = load_by_id(run_id)
output = _get_data_from_ds(ds)
return output
def redraw(run_id, axes, cbars):
'''Call plot_by_id to plot the available data on axes.'''
pause_time = 0.001
dataset = load_by_id(run_id)
if not dataset: # there is not data available yet
axes, cbars = [], []
elif not axes: # there is data available but no plot yet
axes, cbars = plot_by_id(run_id)
else: # there is a plot already
for axis in axes:
axis.clear()
for cbar in cbars:
if cbar is not None:
cbar.remove()
axes, cbars = plot_by_id(run_id, axes)
title = make_title(dataset)
for axis in axes:
axis.set_title(title)
plt.pause(pause_time)
return axes, cbars
def fit(self, dataid, fitclass, save_plots=True, p0=None, **kwargs):
ax_list, _ = plot_by_id(dataid)
popt_list = []
pcov_list = []
for i, ax in enumerate(ax_list):
if ax.lines == []:
print(f'No line found in plot {i}.')
else:
xdata = ax.lines[0].get_xdata()
ydata = ax.lines[0].get_ydata()
# Get initial guess on parameter is guess function is defined
if (p0 is None and hasattr(fitclass, 'guess')):
p0 = getattr(fitclass, 'guess')(xdata, ydata)
popt, pcov = curve_fit(fitclass.fun,
xdata,
ydata,
p0=p0,
**kwargs)
popt_list.append(popt)
pcov_list.append(pcov)
if save_plots:
self.plot_1D(ax, xdata, ydata, fitclass, popt)
dataset = load_by_id(dataid)
mainfolder = config.user.mainfolder
experiment_name = dataset.exp_name
sample_name = dataset.sample_name
storage_dir = os.path.join(mainfolder, experiment_name,
sample_name)
analysis_dir = os.path.join(storage_dir, 'Analysis')
os.makedirs(analysis_dir, exist_ok=True)
full_path = os.path.join(analysis_dir, f'{dataid}_{i}.png')
ax.figure.savefig(full_path, dpi=500)
return popt_list, pcov_list
def test_load_legacy_files_1D(experiment):
location = 'fixtures/2018-01-17/#001_testsweep_15-42-57'
dir = os.path.dirname(__file__)
full_location = os.path.join(dir, location)
run_ids = import_dat_file(full_location)
run_id = run_ids[0]
data = load_by_id(run_id)
assert data.parameters == 'ch1,voltage'
assert data.number_of_results == 201
expected_names = ['ch1', 'voltage']
expected_labels = ['Gate ch1', 'Gate voltage']
expected_units = ['V', 'V']
expected_depends_on = ['', 'ch1']
for i, parameter in enumerate(data.get_parameters()):
assert parameter.name == expected_names[i]
assert parameter.label == expected_labels[i]
assert parameter.unit == expected_units[i]
assert parameter.depends_on == expected_depends_on[i]
assert parameter.type == 'numeric'
snapshot = json.loads(data.get_metadata('snapshot'))
assert sorted(list(snapshot.keys())) == [
'__class__', 'arrays', 'formatter', 'io', 'location', 'loop', 'station'
]
def get_data_by_id(run_id: int) -> List:
"""
Load data from database and reshapes into 1D arrays with minimal
name, unit and label metadata (see `get_layout` function).
Args:
run_id: run ID from the database
Returns:
a list of lists of dictionaries like this:
[
# each element in this list refers
# to one dependent (aka measured) parameter
[
# each element in this list refers
# to one independent (aka setpoint) parameter
# that the dependent parameter depends on;
# a dictionary with the data and metadata of the dependent
# parameter is in the *last* element in this list
...
{
'data': <1D numpy array of points>,
'name': <name of the parameter>,
'label': <label of the parameter or ''>,
'unit': <unit of the parameter or ''>
},
...
],
...
]
"""
data = load_by_id(run_id)
conn = data.conn
deps = get_dependents(conn, run_id)
output = []
for dep in deps:
dependencies = get_dependencies(conn, dep)
data_axis: Dict[str, Union[str, np.ndarray]] = get_layout(conn, dep)
rawdata = data.get_values(data_axis['name'])
data_axis['data'] = flatten_1D_data_for_plot(rawdata)
raw_setpoint_data = data.get_setpoints(data_axis['name'])
output_axes = []
max_size = 0
for dependency in dependencies:
axis: Dict[str,
Union[str,
np.ndarray]] = get_layout(conn, dependency[0])
mydata = flatten_1D_data_for_plot(raw_setpoint_data[axis['name']])
axis['data'] = mydata
size = mydata.size
if size > max_size:
max_size = size
output_axes.append(axis)
for axis in output_axes:
size = axis['data'].size # type: ignore
if size < max_size:
if max_size % size != 0:
raise RuntimeError("Inconsistent shapes of data. Got "
f"{size} which is not a whole fraction"
f"of {max_size}")
axis['data'] = np.repeat(axis['data'], max_size // size)
output_axes.append(data_axis)
output.append(output_axes)
return output
def get_data_by_id(run_id: int, conn: Optional[ConnectionPlus] = None) -> \
List[List[Dict[str, Union[str, np.ndarray]]]]:
"""
Load data from database and reshapes into 1D arrays with minimal
name, unit and label metadata (see `get_layout` function).
Only returns data from parameters that depend on other parameters or
parameters that other parameters depend on, i.e. data for standalone
parameters are not returned.
Args:
run_id: run ID from the database
conn: connection to the database to load from
Returns:
a list of lists of dictionaries like this:
::
[
# each element in this list refers
# to one dependent (aka measured) parameter
[
# each element in this list refers
# to one independent (aka setpoint) parameter
# that the dependent parameter depends on;
# a dictionary with the data and metadata of the dependent
# parameter is in the *last* element in this list
...
{
'data': <1D numpy array of points>,
'name': <name of the parameter>,
'label': <label of the parameter or ''>,
'unit': <unit of the parameter or ''>
},
...
],
...
]
"""
ds = load_by_id(run_id, conn=conn)
dependent_parameters: Tuple[ParamSpecBase, ...] = ds.dependent_parameters
parameter_data = ds.get_parameter_data(
*[ps.name for ps in dependent_parameters])
output = []
for dep_name, data_dict in parameter_data.items():
data_dicts_list = []
dep_data_dict_index = None
for param_name, data in data_dict.items():
my_data_dict: Dict[str, Union[str, np.ndarray]] = {}
my_data_dict['name'] = param_name
my_data_dict['data'] = data.flatten()
ps = ds.paramspecs[param_name]
my_data_dict['unit'] = ps.unit
my_data_dict['label'] = ps.label
data_dicts_list.append(my_data_dict)
if param_name == dep_name:
dep_data_dict_index = len(data_dicts_list) - 1
# put the data dict of the dependent one at the very end of the list
if dep_data_dict_index is None:
raise RuntimeError(f'{dep_name} not found in its own "datadict".')
else:
data_dicts_list.append(data_dicts_list.pop(dep_data_dict_index))
output.append(data_dicts_list)
return output
def test_perform_actual_upgrade_6_to_newest_add_new_data():
"""
Insert new runs on top of existing runs upgraded and verify that they
get the correct captured_run_id and captured_counter
"""
from qcodes.dataset.measurements import Measurement
from qcodes.instrument.parameter import Parameter
import numpy as np
fixpath = os.path.join(fixturepath, 'db_files', 'version6')
db_file = 'some_runs.db'
dbname_old = os.path.join(fixpath, db_file)
if not os.path.exists(dbname_old):
pytest.skip("No db-file fixtures found. You can generate test db-files"
" using the scripts in the "
"https://github.com/QCoDeS/qcodes_generate_test_db/ repo")
with temporarily_copied_DB(dbname_old, debug=False, version=6) as conn:
assert isinstance(conn, ConnectionPlus)
perform_db_upgrade(conn)
assert get_user_version(conn) >= 7
no_of_runs_query = "SELECT max(run_id) FROM runs"
no_of_runs = one(
atomic_transaction(conn, no_of_runs_query), 'max(run_id)')
# Now let's insert new runs and ensure that they also get
# captured_run_id assigned.
params = []
for n in range(5):
params.append(Parameter(f'p{n}', label=f'Parameter {n}',
unit=f'unit {n}', set_cmd=None,
get_cmd=None))
# Set up an experiment
exp = new_experiment('some-exp', 'some-sample', conn=conn)
meas = Measurement(exp=exp)
meas.register_parameter(params[0])
meas.register_parameter(params[1])
meas.register_parameter(params[2], basis=(params[0],))
meas.register_parameter(params[3], basis=(params[1],))
meas.register_parameter(params[4], setpoints=(params[2], params[3]))
# Make a number of identical runs
for _ in range(10):
with meas.run() as datasaver:
for x in np.random.rand(10):
for y in np.random.rand(10):
z = np.random.rand()
datasaver.add_result((params[0], 0),
(params[1], 1),
(params[2], x),
(params[3], y),
(params[4], z))
no_of_runs_new = one(
atomic_transaction(conn, no_of_runs_query), 'max(run_id)')
assert no_of_runs_new == 20
# check that run_id is equivalent to captured_run_id for new
# runs
for run_id in range(no_of_runs, no_of_runs_new + 1):
ds1 = load_by_id(run_id, conn)
ds2 = load_by_run_spec(captured_run_id=run_id, conn=conn)
assert ds1.the_same_dataset_as(ds2)
assert ds1.run_id == run_id
assert ds1.run_id == ds1.captured_run_id
assert ds2.run_id == run_id
assert ds2.run_id == ds2.captured_run_id
# we are creating a new experiment into a db with one exp so:
exp_id = 2
# check that counter is equivalent to captured_counter for new
# runs
for counter in range(1, no_of_runs_new - no_of_runs + 1):
ds1 = load_by_counter(counter, exp_id, conn)
# giving only the counter is not unique since we have 2 experiments
with pytest.raises(NameError, match="More than one"
" matching dataset"):
load_by_run_spec(captured_counter=counter, conn=conn)
# however we can supply counter and experiment
ds2 = load_by_run_spec(captured_counter=counter,
experiment_name='some-exp',
conn=conn)
assert ds1.the_same_dataset_as(ds2)
assert ds1.counter == counter
assert ds1.counter == ds1.captured_counter
assert ds2.counter == counter
assert ds2.counter == ds2.captured_counter
