def test_load_or_create_experiment_creating_not_empty():
"""Test that an experiment is correctly created when DB is not empty"""
exp = load_or_create_experiment("experiment_name_1", "sample_name_1")
exp_2 = load_or_create_experiment("experiment_name_2", "sample_name_2")
actual_experiments = experiments()
assert len(actual_experiments) == 2
assert_experiments_equal(actual_experiments[0], exp)
assert_experiments_equal(actual_experiments[1], exp_2)
def test_load_2dsoftsweep():
qc.config.core.db_location = DBPATH
initialise_database()
exp = load_or_create_experiment('2d_softsweep', sample_name='no sample')
# define some test data
x = np.linspace(0, 1., 5)
y = np.linspace(0, 1., 5)
xx, yy = np.meshgrid(x, y, indexing='ij')
zz = np.random.rand(*xx.shape)
# put data into a new dataset
ds = new_data_set('2d_softsweep',
specs=[ParamSpec('x', 'numeric', unit='A'),
ParamSpec('y', 'numeric', unit='B'),
ParamSpec('z', 'numeric', unit='C',
depends_on=['x', 'y']), ], )
def get_next_result():
for x, y, z in zip(xx.reshape(-1), yy.reshape(-1), zz.reshape(-1)):
yield dict(x=x, y=y, z=z)
results = get_next_result()
for r in results:
ds.add_result(r)
ds.mark_complete()
# retrieve data as data dict
run_id = ds.run_id
ddict = datadict_from_path_and_run_id(DBPATH, run_id)
assert np.all(np.isclose(ddict.data_vals('z'), zz.reshape(-1), atol=1e-15))
assert np.all(np.isclose(ddict.data_vals('x'), xx.reshape(-1), atol=1e-15))
assert np.all(np.isclose(ddict.data_vals('y'), yy.reshape(-1), atol=1e-15))
def test_update_qcloader(qtbot):
qc.config.core.db_location = DBPATH
initialise_database()
exp = load_or_create_experiment('2d_softsweep', sample_name='no sample')
# define test data
x = np.linspace(0, 1., 5)
y = np.linspace(0, 1., 5)
xx, yy = np.meshgrid(x, y, indexing='ij')
zz = np.random.rand(*xx.shape)
def get_2dsoftsweep_results():
for x, y, z in zip(xx.reshape(-1), yy.reshape(-1), zz.reshape(-1)):
yield dict(x=x, y=y, z=z)
# create data set
_ds = new_data_set(
'2d_softsweep',
exp_id=exp.exp_id,
specs=[
ParamSpec('x', 'numeric', unit='A'),
ParamSpec('y', 'numeric', unit='B'),
ParamSpec('z', 'numeric', unit='C', depends_on=['x', 'y']),
],
)
run_id = _ds.run_id
results = get_2dsoftsweep_results()
# setting up the flowchart
nodes, fc = make_sequential_flowchart([QCodesDSLoader])
loader = nodes[0]
loader.pathAndId = DBPATH, run_id
def check():
nresults = _ds.number_of_results
loader.update()
ddict = fc.output()['dataOut']
z_in = zz.reshape(-1)[:nresults]
z_out = ddict.data_vals('z')
if z_out is not None:
assert z_in.size == z_out.size
assert np.allclose(z_in, z_out, atol=1e-15)
# insert data in small chunks, and check
while True:
try:
ninsertions = np.random.randint(0, 5)
for n in range(ninsertions):
_ds.add_result(next(results))
except StopIteration:
_ds.mark_complete()
break
check()
check()
def do_experiment(experiment_name,
sweep_object,
setup=None,
cleanup=None,
station=None,
live_plot=False):
if "/" in experiment_name:
experiment_name, sample_name = experiment_name.split("/")
else:
sample_name = None
experiment = load_or_create_experiment(experiment_name, sample_name)
def add_actions(action, callables):
if callables is None:
return
for cabble in np.atleast_1d(callables):
if not isinstance(cabble, tuple):
cabble = (cabble, ())
action(*cabble)
if live_plot:
try:
from plottr.qcodes_dataset import QcodesDatasetSubscriber
from plottr.tools import start_listener
start_listener()
except ImportError:
warn("Cannot perform live plots, plottr not installed")
live_plot = False
meas = SweepMeasurement(exp=experiment, station=station)
meas.register_sweep(sweep_object)
add_actions(meas.add_before_run, setup)
add_actions(meas.add_after_run, cleanup)
with meas.run() as datasaver:
if live_plot:
datasaver.dataset.subscribe(QcodesDatasetSubscriber(
datasaver.dataset),
state=[],
min_wait=0,
min_count=1)
for data in sweep_object:
datasaver.add_result(*data.items())
return _DataExtractor(datasaver)
def test_load_or_create_experiment_different_sample_name():
"""
Test that an experiment is created for the case when the experiment
name is the same, but the sample name is different
"""
exp = new_experiment("experiment_name", "sample_name_1")
exp_2 = load_or_create_experiment("experiment_name", "sample_name_2")
actual_experiments = experiments()
assert len(actual_experiments) == 2
assert exp.name == exp_2.name
assert exp.sample_name != exp_2.sample_name
def test_real_dataset_2d(two_empty_temp_db_connections, inst):
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp = load_or_create_experiment(experiment_name="myexp",
conn=source_conn)
source_dataset, _, _ = do2d(inst.back,
0,
1,
10,
0,
inst.plunger,
0,
0.1,
15,
0,
inst.cutter,
exp=source_exp)
extract_runs_into_db(source_path, target_path, source_dataset.run_id)
target_dataset = load_by_guid(source_dataset.guid, conn=target_conn)
assert source_dataset.the_same_dataset_as(target_dataset)
# explicit regression test for https://github.com/QCoDeS/Qcodes/issues/3953
assert source_dataset.description.shapes == {
"extract_run_inst_cutter": (10, 15)
}
assert source_dataset.description.shapes == target_dataset.description.shapes
source_data = source_dataset.get_parameter_data(
)["extract_run_inst_cutter"]
target_data = target_dataset.get_parameter_data(
)["extract_run_inst_cutter"]
for source_data, target_data in zip(source_data.values(),
target_data.values()):
assert_array_equal(source_data, target_data)
def generate_local_exp(dbpath: Path) -> List[str]:
with initialised_database_at(str(dbpath)):
guids = []
exp = load_or_create_experiment(experiment_name="test_guid")
p1 = Parameter('Voltage', set_cmd=None)
p2 = Parameter('Current', get_cmd=np.random.randn)
meas = Measurement(exp=exp)
meas.register_parameter(p1).register_parameter(p2, setpoints=[p1])
# Meaure for 2 times to get 2 run ids and 2 guids
for run in range(2):
with meas.run() as datasaver:
for v in np.linspace(0 * run, 2 * run, 50):
p1(v)
datasaver.add_result((p1, cast(float, p1())),
(p2, cast(float, p2())))
guid = datasaver.dataset.guid
guids.append(guid)
return guids
def test_active_experiment(empty_temp_db):
conn = conn_from_dbpath_or_conn(conn=None, path_to_db=empty_temp_db)
with pytest.raises(ValueError):
get_default_experiment_id(conn)
exp_1 = load_or_create_experiment("test_exp", sample_name="no_sample")
assert get_default_experiment_id(conn) == exp_1.exp_id
exp_2 = new_experiment("test_exp_2", sample_name="no_sample")
assert get_default_experiment_id(conn) == exp_2.exp_id
exp_3 = load_experiment(1)
assert get_default_experiment_id(conn) == exp_1.exp_id
assert get_default_experiment_id(conn) == exp_3.exp_id
exp_4 = new_experiment("test_exp_3", sample_name="no_sample")
exp_5 = load_experiment_by_name("test_exp_2", sample="no_sample")
assert get_default_experiment_id(conn) == exp_2.exp_id
assert get_default_experiment_id(conn) == exp_5.exp_id
exp_6 = load_last_experiment()
assert get_default_experiment_id(conn) == exp_4.exp_id
assert get_default_experiment_id(conn) == exp_6.exp_id
last_exp = new_experiment("last_exp", sample_name="no_sample")
load_experiment(3)
reset_default_experiment_id(conn)
assert get_default_experiment_id(conn) is last_exp.exp_id
load_experiment(exp_1.exp_id)
assert get_default_experiment_id(conn) == exp_1.exp_id
reset_default_experiment_id()
assert get_default_experiment_id(conn) is last_exp.exp_id
def test_load_or_create_experiment_creating():
"""Test that an experiment is correctly created"""
exp = load_or_create_experiment("experiment_name", "sample_name")
exp_2 = load_experiment_by_name("experiment_name", "sample_name")
assert_experiments_equal(exp, exp_2)
)
self.setpoints = (tuple(), tuple())
self.setpoint_shapes = (tuple(), tuple())
self.setpoint_labels = (("I channel", ), ('Q channel', ))
self.setpoint_units = (("mV", ), ("mV", ))
self.setpoint_names = (("I_channel", ), ("Q_channel", ))
self.i = 2
def get_raw(self):
self.i += 1
return (self.i, self.i + 100)
now = str(datetime.datetime.now())
path = os.path.join(os.getcwd(), 'test.db')
initialise_or_create_database_at(path)
load_or_create_experiment('tutorial ' + now, 'no sample')
my_param = MyCounter('test_instr')
from qcodes.instrument.specialized_parameters import ElapsedTimeParameter
x = qc.Parameter(name='x',
label='Voltage_x',
unit='V',
set_cmd=None,
get_cmd=None)
y = qc.Parameter(name='y',
label='Voltage_y',
unit='V',
set_cmd=None,
get_cmd=None)
timer = ElapsedTimeParameter('time')
my_param_multi_test = dummy_multi_parameter_2dawg('param')
from qdev_wrappers.station_configurator import StationConfigurator
import qcodes_measurements as qcm
from qcodes_measurements.plot.plot_tools import *
from qcodes_measurements.device import *
from dac_params import *
# Log all output
from IPython import get_ipython
ip = get_ipython()
ip.magic("logstop")
ip.magic("logstart -o -t iPython_Logs\\fivedot_analysis_log.py rotate")
ip.magic("autoreload 0")
# Close any instruments that may already be open
instruments = list(qc.Instrument._all_instruments.keys())
for instrument in instruments:
instr = qc.Instrument._all_instruments.pop(instrument)
instr = instr()
instr.close()
del instruments
exp_name = 'QDP_FIVEDOT'
sample_name = 'DARLINGTON_D1'
initialise_database()
exp = load_or_create_experiment(exp_name, sample_name)
print('Experiment loaded. Last ID no:', exp.last_counter)
osc.ch4.t_start.set(-10)
osc.ch4.t_stop.set(10)
amp = 1
PSG1.amp(amp)
PSG2.amp(amp)
station = Station()
station.snapshot()
station.add_component(osc)
# Criar um database
initialise_or_create_database_at("~/teste.db")
exp = load_or_create_experiment(experiment_name='osc realtime intro 2',
sample_name="osc realtime 1")
def calculateGain():
Y = osc.ch3.wavesample()
n_mean = int(len(Y) / 2)
value = 2 * np.mean(Y[n_mean:])
value = 10 * np.log(np.power(value, 2))
return value
gain = Parameter('gain', label='gain', unit='dB', get_cmd=calculateGain)
# Medida de fato
meas = Measurement(exp=exp, station=station)
def test_load_or_create_experiment_loading(empty_temp_db):
"""Test that an experiment is correctly loaded"""
exp = new_experiment("experiment_name", "sample_name")
exp_2 = load_or_create_experiment("experiment_name", "sample_name")
assert_experiments_equal(exp, exp_2)
