def do_2d_sweep():
# Create the DAQ object
daq = Daq("Dev1", "testdaq")
# Initialize the database you want to save data to
try:
experimentName = "testexp-2d_5"
sampleName = "sampletest-2d"
initialise_or_create_database_at(
'C:\\Users\\erunb\\MeasureIt\\Databases\\testdatabase.db')
qc.new_experiment(name=experimentName, sample_name=sampleName)
except:
print("Error opening database")
daq.device.reset_device()
daq.__del__()
quit()
# Create the sweep argument, tell it which channel to listen to
# Sweep parameter arguments are:
# [ <QCoDeS Parameter>, start value, stop value, step value ]
in_sweep_params = [daq.submodules["ao0"].voltage, 0, 1, 0.1]
out_sweep_params = [daq.submodules["ao1"].voltage, 0, 5, 1]
freq = 1000
# "measured" parameter
param = daq.submodules["ai3"].voltage
s = Sweep2D(in_sweep_params, out_sweep_params, freq, param)
# Run the sweep automatically
s.autorun()
# Clean up the DAQ
daq.__del__()
def init_database(db, exp, samp, sweep=None):
"""
Initializes a new database with exp and sample names and creates a new measurement if a sweep is set.
Parameters
---------
db:
The desired path of the new database.
exp:
The experiment name.
sample:
The sample name.
sweep=None:
Optional weep object for creating new runs for existing sweeps
"""
if '.db' not in db:
db = f'{db}.db'
if f'{os.environ["MeasureItHome"]}\\Databases\\' in db:
initialise_or_create_database_at(db)
else:
initialise_or_create_database_at(os.environ['MeasureItHome'] +
'\\Databases\\' + db)
qc.new_experiment(exp, samp)
if sweep is not None:
sweep._create_measurement()
def set_database(self):
"""
Changes the database for the next run. Pops out the next item in a list, if that
is what was loaded, or keeps the same string.
"""
# Grab the next database file name
db = ""
if isinstance(self.database, str):
db = self.database
elif isinstance(self.database, deque):
db = self.database.popleft()
# Grab the next sample name
sample = ""
if isinstance(self.sample_name, str):
sample = self.sample_name
elif isinstance(self.sample_name, deque):
sample = self.sample_name.popleft()
# Grab the next experiment name
exp = ""
if isinstance(self.exp_name, str):
exp = self.exp_name
elif isinstance(self.exp_name, deque):
exp = self.exp_name.popleft()
# Initialize the database
try:
initialise_or_create_database_at(
'C:\\Users\\Nanouser\\Documents\\MeasureIt\\Databases\\' + db +
'.db')
qc.new_experiment(name=exp, sample_name=sample)
except:
print("Database info loaded incorrectly!")
def test_foreground_twice(empty_temp_db_connection):
new_experiment("test", "test1", conn=empty_temp_db_connection)
ds1 = DataSet(conn=empty_temp_db_connection)
ds1.mark_started(start_bg_writer=False)
ds2 = DataSet(conn=empty_temp_db_connection)
ds2.mark_started(start_bg_writer=False)
def test_foreground_after_background_raises(empty_temp_db_connection):
new_experiment("test", "test1", conn=empty_temp_db_connection)
ds1 = DataSet(conn=empty_temp_db_connection)
ds1.mark_started(start_bg_writer=True)
ds2 = DataSet(conn=empty_temp_db_connection)
with pytest.raises(RuntimeError, match="All datasets written"):
ds2.mark_started(start_bg_writer=False)
def start(self):
"""
Sets the database to the values given at initialization, then calls the callback function
"""
initialise_or_create_database_at(self.db)
qc.new_experiment(name=self.exp, sample_name=self.samp)
if self.callback is not None and callable(self.callback):
self.callback()
def test_foreground_after_background_non_concurrent(empty_temp_db_connection):
new_experiment("test", "test1", conn=empty_temp_db_connection)
ds1 = DataSet(conn=empty_temp_db_connection)
ds1.mark_started(start_bg_writer=True)
ds1.mark_completed()
ds2 = DataSet(conn=empty_temp_db_connection)
ds2.mark_started(start_bg_writer=False)
ds2.mark_completed()
ds3 = DataSet(conn=empty_temp_db_connection)
ds3.mark_started(start_bg_writer=True)
ds3.mark_completed()
def load_experiment(sample_batch, sample_name):
station = qc.Station.default
# Set up folders, settings and logging for the experiment
my_init(sample_batch + sample_name,
station,
pdf_folder=False,
png_folder=False,
analysis_folder=True,
waveforms_folder=False,
calib_config=False,
annotate_image=False,
mainfolder="D:/data/",
display_pdf=False,
display_individual_pdf=False,
qubit_count=2)
new_experiment(sample_batch, sample_name)
def load_or_create_experiment(experiment_name: str,
sample_name: str) -> Experiment:
"""
Find and return an experiment with the given name and sample name,
or create one if not found.
Note: this function similar to pytopo.select_experiment().
Args:
experiment_name
Name of the experiment to find or create
sample_name
Name of the sample
Returns:
The found or created experiment
"""
try:
experiment = qcodes.load_experiment_by_name(experiment_name,
sample_name)
except ValueError as exception:
if "Experiment not found" in str(exception):
experiment = qcodes.new_experiment(experiment_name, sample_name)
else:
raise exception
return experiment
def test_add_experiments(empty_temp_db, experiment_name,
sample_name, dataset_name):
global n_experiments
n_experiments += 1
_ = new_experiment(experiment_name, sample_name=sample_name)
exps = experiments()
assert len(exps) == n_experiments
exp = exps[-1]
assert exp.name == experiment_name
assert exp.sample_name == sample_name
assert exp.last_counter == 0
dataset = new_data_set(dataset_name)
dsid = dataset.run_id
loaded_dataset = load_by_id(dsid)
expected_ds_counter = 1
assert loaded_dataset.name == dataset_name
assert loaded_dataset.counter == expected_ds_counter
assert loaded_dataset.table_name == "{}-{}-{}".format(dataset_name,
exp.exp_id,
loaded_dataset.counter)
expected_ds_counter += 1
dataset = new_data_set(dataset_name)
dsid = dataset.run_id
loaded_dataset = load_by_id(dsid)
assert loaded_dataset.name == dataset_name
assert loaded_dataset.counter == expected_ds_counter
assert loaded_dataset.table_name == "{}-{}-{}".format(dataset_name,
exp.exp_id,
loaded_dataset.counter)
def experiment_doubledots(empty_temp_db):
e = new_experiment("test_experiment", sample_name="test_sample")
populate_db_doubledots()
try:
yield e
finally:
e.conn.close()
def do_1d_sweep(_min_v, _max_v, _step, _freq, _expName, _sampleName):
# Create the DAQ object
daq = Daq("Dev1", "testdaq")
# Initialize the database you want to save data to
try:
experimentName = _expName
sampleName = _sampleName
initialise_or_create_database_at(
'C:\\Users\\erunb\\MeasureIt\\Databases\\testdatabase.db')
qc.new_experiment(name=experimentName, sample_name=sampleName)
except:
print("Error opening database")
daq.device.reset_device()
daq.__del__()
quit()
# Set our sweeping parameters
min_v = _min_v
max_v = _max_v
step = _step
freq = _freq
# Create the sweep argument, tell it which channel to listen to
s = Sweep1D(daq.submodules["ao0"].voltage,
min_v,
max_v,
step,
freq,
bidirectional=True,
meas=None,
plot=True,
auto_figs=True)
s.follow_param(daq.submodules["ai3"].voltage)
s._create_measurement((s.set_param))
# Run the sweep automatically
s.autorun()
# Clean up the DAQ
daq.__del__()
# Show the experiment data
ex = qc.dataset.experiment_container.load_experiment_by_name(
experimentName, sampleName)
fii = get_data_by_id(ex.data_sets()[0].run_id)
print(fii)
def init_sweep(self):
if self.daq is None:
msg = QMessageBox()
msg.setText("DAQ is not connected!")
msg.setWindowTitle("Sweep Error")
msg.setStandardButtons(QMessageBox.Close)
msg.exec_()
return
self.v_start = _value_parser(self.min_v_val.text())
self.v_end = _value_parser(self.max_v_val.text())
try:
self.v_step = float(self.step_v_val.text())
if self.v_step > 0 and self.v_end < self.v_start:
self.v_step = -1 * self.v_step
except ValueError:
self.v_step = (self.v_end - self.v_start) / 1000
try:
self.freq = float(self.steprate_val.text())
except ValueError:
self.freq = 10
ichannel = "ai" + str(int(self.in_chan_box.currentText()))
self.ochannel = "ao" + str(int(self.out_chan_box.currentText()))
self.sweep_task = nidaqmx.Task()
self.daq.submodules[self.ochannel].add_self_to_task(self.sweep_task)
self.s = Sweep1D(self.daq.submodules[self.ochannel].voltage,
self.v_start, self.v_end, self.v_step, self.freq)
self.s.follow_param(self.daq.submodules[ichannel].voltage)
self.meas = self.s.get_measurement()
self.counter = 0
self.init_plot(self.daq.submodules[self.ochannel].voltage,
self.daq.submodules[ichannel].voltage)
initialise_or_create_database_at(
'C:\\Users\\erunb\\MeasureIt\\Databases\\testdb.db')
qc.new_experiment(name='demotest3', sample_name='my best sample3')
self.sweeping = True
self.running = True
self.curr_val = self.v_start
self.run()
def setup_save(self):
save_data_ui = SaveDataGUI(self, self.db, self.exp_name,
self.sample_name)
if save_data_ui.exec_():
(self.db, self.exp_name,
self.sample_name) = save_data_ui.get_save_info()
try:
initialise_or_create_database_at(self.db)
qc.new_experiment(self.exp_name, self.sample_name)
self.db_set = True
return True
except Exception as e:
self.show_error('Error',
"Error opening up database. Try again.", e)
return False
else:
return False
def test_dataset_location(empty_temp_db_connection):
"""
Test that an dataset and experiment points to the correct db file when
a connection is supplied.
"""
exp = new_experiment("test", "test1", conn=empty_temp_db_connection)
ds = DataSet(conn=empty_temp_db_connection)
assert path_to_dbfile(empty_temp_db_connection) == \
empty_temp_db_connection.path_to_dbfile
assert exp.path_to_db == empty_temp_db_connection.path_to_dbfile
assert ds.path_to_db == empty_temp_db_connection.path_to_dbfile
def benchmark_add_results_vs_MAX_VARIABLE_NUMBER():
filename = 'benchmark_add_results_vs_MAX_VARIABLE_NUMBER.png'
if no_plots:
return filename
plt.figure()
xr, yr = [], []
mvn = qc.SQLiteSettings.limits['MAX_VARIABLE_NUMBER']
for i in range(2, mvn, mvn // 50):
ts = []
for j in range(3):
qc.SQLiteSettings.limits['MAX_VARIABLE_NUMBER'] = i
new_experiment("profile", "profile")
data_set = new_data_set("stress_test_simple")
t1 = ParamSpec('t', 'numeric', label='time', unit='s')
x = ParamSpec('x',
'numeric',
label='voltage',
unit='v',
depends_on=[t1])
data_set.add_parameter(t1)
data_set.add_parameter(x)
insertion_size = 400 * 600
t_values = np.linspace(-1, 1, insertion_size)
results = [{"t": t, "x": 2 * t**2 + 1} for t in t_values]
t1r = time.time()
data_set.add_results(results)
t = time.time() - t1r
ts.append(t)
xr.append(i)
yr.append(mean(ts))
plt.plot(xr, yr)
plt.ylabel('execution time of data_set.add_results(result)')
plt.xlabel('MAX_VARIABLE_NUMBER')
plt.savefig(filename)
return filename
def second_third_experiment_labelled_data(second_empty_temp_db, tmp_path):
e1 = new_experiment("test_experiment2", sample_name="test_sample")
e2 = new_experiment("test_experiment3", sample_name="test_sample")
for did in range(len(test_data_labels2)):
ds = DataSet(os.path.join(tmp_path, "temp2.db"), exp_id=e2._exp_id)
nt_metadata, current_label = generate_default_metadata()
stage = test_data_labels2[did]
if stage is not None:
current_label[stage] = 1
ds.add_metadata(nt.meta_tag, json.dumps(nt_metadata))
ds.add_metadata("snapshot", json.dumps({}))
for label, value in current_label.items():
ds.add_metadata(label, value)
try:
yield e2
finally:
e1.conn.close()
e2.conn.close()
def set_database(self):
"""
Sets the loaded database information for each sweep before running.
Database information must be previously loaded using the 'load_database_info'
method. Creates path for database and begins a new QCoDeS experiment.
"""
# Grab the next database file name
if self.database is None:
return
db = ""
if isinstance(self.database, str):
db = self.database
elif isinstance(self.database, deque):
db = self.database.popleft()
# Grab the next sample name
sample = ""
if isinstance(self.sample_name, str):
sample = self.sample_name
elif isinstance(self.sample_name, deque):
sample = self.sample_name.popleft()
# Grab the next experiment name
exp = ""
if isinstance(self.exp_name, str):
exp = self.exp_name
elif isinstance(self.exp_name, deque):
exp = self.exp_name.popleft()
# Initialize the database
try:
initialise_or_create_database_at(os.environ['MeasureItHome'] +
'\\Databases\\' + db + '.db')
qc.new_experiment(name=exp, sample_name=sample)
except:
print("Database info loaded incorrectly!")
def experiment_partially_labelled(empty_temp_db, tmp_path):
e = new_experiment("test_experiment", sample_name="test_sample")
for did in range(len(test_data_labels)):
ds = DataSet(os.path.join(tmp_path, "temp.db"))
nt_metadata, current_label = generate_default_metadata()
stage = test_data_labels[did]
if stage is not None:
current_label[stage] = 1
for label, value in current_label.items():
ds.add_metadata(label, value)
ds.add_metadata(nt.meta_tag, json.dumps(nt_metadata))
ds.add_metadata("snapshot", json.dumps({}))
try:
yield e
finally:
e.conn.close()
def test_nest():
n_sample_points = 100
x = ManualParameter("x")
sweep_values_x = np.linspace(-1, 1, n_sample_points)
y = ManualParameter("y")
sweep_values_y = np.linspace(-1, 1, n_sample_points)
m = ManualParameter("m")
m.get = lambda: np.sin(x())
n = ManualParameter("n")
n.get = lambda: np.cos(x()) + 2 * np.sin(y())
sweep_object = sweep(x, sweep_values_x)(m, sweep(y, sweep_values_y)(n))
experiment = new_experiment("sweep_measure", sample_name="sine")
station = Station()
meas = SweepMeasurement(exp=experiment, station=station)
meas.register_sweep(sweep_object)
with meas.run() as datasaver:
for data in sweep_object:
datasaver.add_result(*data.items())
data_set = datasaver._dataset
assert data_set.paramspecs["x"].depends_on == ""
assert data_set.paramspecs["y"].depends_on == ""
assert data_set.paramspecs["m"].depends_on == "x"
assert data_set.paramspecs["n"].depends_on == "x, y"
data_x = data_set.get_data('x')
data_y = data_set.get_data('y')
assert data_x[::n_sample_points + 1] == [[xi] for xi in sweep_values_x]
assert data_y[::n_sample_points + 1] == [[None] for _ in sweep_values_x]
coordinate_layout = itertools.product(sweep_values_x, sweep_values_y)
expected_x, expected_y = zip(*coordinate_layout)
assert [ix for c, ix in enumerate(data_x)
if c % (n_sample_points + 1)] == [[xi] for xi in expected_x]
assert [iy for c, iy in enumerate(data_y)
if c % (n_sample_points + 1)] == [[yi] for yi in expected_y]
def experiment_ideal_run(empty_temp_db):
e = new_experiment("test_tuning_run", sample_name="test_sample")
for run_id in range(len(ideal_run_labels)):
label = ideal_run_labels[run_id]
if label == 'pinchoff':
_ = save_1Ddata_with_qcodes(
generate_pinchoff_data,
generate_pinchoff_metadata,
)
elif label == 'doubledot':
_ = save_2Ddata_with_qcodes(
generate_doubledot_data,
generate_doubledot_metadata,
)
else:
raise NotImplementedError
try:
yield e
finally:
e.conn.close()
def test_inferred():
x = ManualParameter("x", unit="V")
@setter([("xmv", "mV")], inferred_parameters=[("x", "V")])
def xsetter(milivolt_value):
volt_value = milivolt_value / 1000.0 # From mV to V
x.set(volt_value)
return volt_value
m = ManualParameter("m")
m.get = lambda: np.sin(x())
sweep_values = np.linspace(-1000, 1000, 100) # We sweep in mV
sweep_object = nest(sweep(xsetter, sweep_values), m)
experiment = new_experiment("sweep_measure", sample_name="sine")
station = Station()
meas = SweepMeasurement(exp=experiment, station=station)
meas.register_sweep(sweep_object)
with meas.run() as datasaver:
for data in sweep_object:
datasaver.add_result(*data.items())
data_set = datasaver._dataset
assert data_set.paramspecs["x"].depends_on == ""
assert data_set.paramspecs["x"].inferred_from == "xmv"
assert data_set.paramspecs["xmv"].depends_on == ""
assert data_set.paramspecs["m"].depends_on == "x"
expected_xmv = [[xi] for xi in sweep_values]
expected_x = [[xi / 1000] for xi in sweep_values]
assert data_set.get_data('xmv') == expected_xmv
assert data_set.get_data('x') == expected_x
def test_simple():
x = ManualParameter("x")
sweep_values = np.linspace(-1, 1, 100)
m = ManualParameter("m")
m.get = lambda: np.sin(x())
sweep_object = nest(sweep(x, sweep_values), m)
experiment = new_experiment("sweep_measure", sample_name="sine")
station = Station()
meas = SweepMeasurement(exp=experiment, station=station)
meas.register_sweep(sweep_object)
with meas.run() as datasaver:
for data in sweep_object:
datasaver.add_result(*data.items())
data_set = datasaver._dataset
assert data_set.paramspecs["x"].depends_on == ""
assert data_set.paramspecs["m"].depends_on == "x"
expected_x = [[xi] for xi in sweep_values]
assert data_set.get_data('x') == expected_x
def experiment(empty_temp_db):
e = qc.new_experiment("test-experiment", sample_name="test-sample")
yield e
e.conn.close()
def test_update_existing_guids(caplog):
old_loc = 101
old_ws = 1200
new_loc = 232
new_ws = 52123
# prepare five runs with different location and work station codes
with location_and_station_set_to(0, 0):
new_experiment('test', sample_name='test_sample')
ds1 = new_data_set('ds_one')
xparam = ParamSpec('x', 'numeric')
ds1.add_parameter(xparam)
ds1.add_result({'x': 1})
ds2 = new_data_set('ds_two')
ds2.add_parameter(xparam)
ds2.add_result({'x': 2})
guid_comps_1 = parse_guid(ds1.guid)
assert guid_comps_1['location'] == 0
assert guid_comps_1['work_station'] == 0
guid_comps_2 = parse_guid(ds2.guid)
assert guid_comps_2['location'] == 0
assert guid_comps_2['work_station'] == 0
with location_and_station_set_to(0, old_ws):
ds3 = new_data_set('ds_three')
xparam = ParamSpec('x', 'numeric')
ds3.add_parameter(xparam)
ds3.add_result({'x': 3})
with location_and_station_set_to(old_loc, 0):
ds4 = new_data_set('ds_four')
xparam = ParamSpec('x', 'numeric')
ds4.add_parameter(xparam)
ds4.add_result({'x': 4})
with location_and_station_set_to(old_loc, old_ws):
ds5 = new_data_set('ds_five')
xparam = ParamSpec('x', 'numeric')
ds5.add_parameter(xparam)
ds5.add_result({'x': 5})
with location_and_station_set_to(new_loc, new_ws):
caplog.clear()
expected_levels = [
'INFO', 'INFO', 'INFO', 'INFO', 'INFO', 'INFO', 'WARNING', 'INFO',
'WARNING', 'INFO', 'INFO'
]
with caplog.at_level(logging.INFO):
update_GUIDs(ds1.conn)
for record, lvl in zip(caplog.records, expected_levels):
assert record.levelname == lvl
guid_comps_1 = parse_guid(ds1.guid)
assert guid_comps_1['location'] == new_loc
assert guid_comps_1['work_station'] == new_ws
guid_comps_2 = parse_guid(ds2.guid)
assert guid_comps_2['location'] == new_loc
assert guid_comps_2['work_station'] == new_ws
guid_comps_3 = parse_guid(ds3.guid)
assert guid_comps_3['location'] == 0
assert guid_comps_3['work_station'] == old_ws
guid_comps_4 = parse_guid(ds4.guid)
assert guid_comps_4['location'] == old_loc
assert guid_comps_4['work_station'] == 0
guid_comps_5 = parse_guid(ds5.guid)
assert guid_comps_5['location'] == old_loc
assert guid_comps_5['work_station'] == old_ws
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
from qcodes import Monitor
from qcodes import ManualParameter
from qdev_wrappers.file_setup import CURRENT_EXPERIMENT, my_init, close_station
from qdev_wrappers.station_configurator import StationConfigurator
from qcodes.dataset.plotting import plot_by_id
from qcodes.dataset.data_set import load_by_id
from qcodes.dataset.data_export import get_data_by_id
from qcodes import new_experiment, Parameter
from qcodes.dataset.measurements import Measurement
from qdev_wrappers.sweep_functions import do0d, do1d, do2d
from qcodes import ParamSpec, new_data_set
from qdev_wrappers.export import export_by_id
from local_instruments.qdev_fitter_QT1 import qdev_fitter
if FIRST_INITIALISATION:
exp = new_experiment(EXPERIMENT_NAME, sample_name=SAMPLE_NAME)
scriptfolder = qc.config.user.scriptfolder
sys.path.append(scriptfolder)
mpl.rcParams['figure.subplot.bottom'] = 0.15
mpl.rcParams['font.size'] = 10
mpl.rcParams['image.cmap'] = 'hot'
if __name__ == '__main__':
if qc.Station.default:
close_station(qc.Station.default)
STATION = qc.Station()
def experiment(empty_temp_db):
e = new_experiment("test-experiment", sample_name="test-sample")
try:
yield e
finally:
e.conn.close()
def save_segmented_data_return_info(
self,
segment_db_name: str,
segment_db_folder: Optional[str] = None,
) -> Dict[int, Dict[str, Dict[str, Tuple[float, float]]]]:
"""
Save each mesh in a new dataset in given databases
returns:
segment_info = {
data_id: {
readout_method: {'range_x': (),
'range_y': ()
}
}
}
"""
if segment_db_folder is None:
segment_db_folder = nt.config["db_folder"]
if not self.segmented_data:
self.prepare_segmented_data(use_raw_data=True)
if not os.path.isfile(os.path.join(segment_db_folder, segment_db_name)):
ds = load_by_id(self.qc_run_id)
nt.new_database(segment_db_name, db_folder=segment_db_folder)
qc.new_experiment(f'segmented_{ds.exp_name}',
sample_name=ds.sample_name)
original_params = self.qc_parameters
segment_info: Dict[int, Dict[str, Dict[str, Tuple[float, float]]]] = {}
with nt.switch_database(segment_db_name, segment_db_folder):
for segment in self.segmented_data:
meas = Measurement()
meas.register_custom_parameter(
original_params[0].name,
label=original_params[0].label,
unit=original_params[0].unit,
paramtype="array",
)
meas.register_custom_parameter(
original_params[1].name,
label=original_params[1].label,
unit=original_params[1].unit,
paramtype="array",
)
result: List[List[Tuple[str, np.ndarray]]] = []
ranges: Dict[str, Dict[str, Tuple[float, float]]] = {}
m_params = [str(it) for it in list(segment.data_vars)]
for ip, param_name in enumerate(m_params):
coord_names = list(segment.coords)
x_crd_name = coord_names[0]
y_crd_name = coord_names[1]
voltage_x = segment[param_name][x_crd_name].values
voltage_y = segment[param_name][y_crd_name].values
signal = segment[param_name].values
range_x = (np.min(voltage_x), np.max(voltage_x))
range_y = (np.min(voltage_y), np.max(voltage_y))
ranges[param_name] = {}
ranges[param_name]["range_x"] = range_x
ranges[param_name]["range_y"] = range_y
setpoints = self.raw_data[param_name].depends_on
meas.register_custom_parameter(
original_params[ip+2].name,
label=original_params[ip+2].label,
unit=original_params[1].unit,
paramtype="array",
setpoints=setpoints,
)
v_x_grid, v_y_grid = np.meshgrid(voltage_x, voltage_y)
result.append([(setpoints[0], v_x_grid),
(setpoints[1], v_y_grid),
(param_name, signal.T)])
with meas.run() as datasaver:
for r_i in range(len(self.readout_methods)):
datasaver.add_result(*result[r_i])
datasaver.dataset.add_metadata(
"snapshot", json.dumps(self.snapshot)
)
datasaver.dataset.add_metadata(
nt.meta_tag, json.dumps(self.nt_metadata)
)
datasaver.dataset.add_metadata(
"original_guid", json.dumps(self.guid)
)
logger.debug(
"New dataset created and populated.\n"
+ "database: "
+ str(segment_db_name)
+ "ID: "
+ str(datasaver.run_id)
)
segment_info[datasaver.run_id] = ranges
return segment_info
def set_experiment_sample_names(sweep, exp, samp):
""" Creates a new measurement with desired experiment and sample names. """
if sweep.save_data is True:
qc.new_experiment(exp, samp)
sweep._create_measurement()
