def test_nest_3d(indep_params, dep_params):
px, x, tablex = indep_params["x"]
py, y, tabley = indep_params["y"]
pz, z, tablez = indep_params["z"]
def f(vx, vy, vz):
return vx**2 + vy**2 + vz**2
pi, i, tablei = dep_params["i"]
pi.get = lambda: f(px(), py(), pz())
sweep_values_x = [0, 1, 2]
sweep_values_y = [5, 6, 7]
sweep_values_z = [8, 9, 10]
nest = Nest(Sweep(x, tablex, lambda: sweep_values_x),
Sweep(y, tabley, lambda: sweep_values_y),
Sweep(z, tablez, lambda: sweep_values_z), Measure(i, tablei))
meas = SweepMeasurement()
meas.register_sweep(nest)
interdeps = meas._interdeps
assert interdeps.dependencies == {
ParamSpecBase('i', 'numeric', '', ''):
(ParamSpecBase('x', 'numeric', '',
''), ParamSpecBase('y', 'numeric', '', ''),
ParamSpecBase('z', 'numeric', '', ''))
}
assert interdeps.inferences == {}
assert interdeps.standalones == set()
def dataset_with_outliers_generator(ds,
data_offset=5,
low_outlier=-3,
high_outlier=1,
background_noise=True):
x = ParamSpecBase('x', 'numeric', label='Flux', unit='e^2/hbar')
t = ParamSpecBase('t', 'numeric', label='Time', unit='s')
z = ParamSpecBase('z', 'numeric', label='Majorana number', unit='Anyon')
idps = InterDependencies_(dependencies={z: (x, t)})
ds.set_interdependencies(idps)
ds.mark_started()
npoints = 50
xvals = np.linspace(0, 1, npoints)
tvals = np.linspace(0, 1, npoints)
for counter, xv in enumerate(xvals):
if background_noise and (counter < round(npoints / 2.3)
or counter > round(npoints / 1.8)):
data = np.random.rand(npoints) - data_offset
else:
data = xv * np.linspace(0, 1, npoints)
if counter == round(npoints / 1.9):
data[round(npoints / 1.9)] = high_outlier
if counter == round(npoints / 2.1):
data[round(npoints / 2.5)] = low_outlier
ds.add_results([{
'x': xv,
't': tv,
'z': z
} for z, tv in zip(data, tvals)])
ds.mark_completed()
return ds
def test_set_interdependencies(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameter_a = ParamSpecBase("a_param", "NUMERIC")
parameter_b = ParamSpecBase("b_param", "NUMERIC")
parameter_c = ParamSpecBase("c_param", "array")
idps = InterDependencies_(
inferences={parameter_c: (parameter_a, parameter_b)})
dataset.set_interdependencies(idps)
# write the parameters to disk
dataset.mark_started()
# Now retrieve the paramspecs
shadow_ds = make_shadow_dataset(dataset)
paramspecs = shadow_ds.paramspecs
expected_keys = ['a_param', 'b_param', 'c_param']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert paramspecs == dataset.paramspecs
def test_add_data_array():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
idps = InterDependencies_(standalones=(ParamSpecBase("x", "numeric"),
ParamSpecBase("y", "array")))
mydataset = new_data_set("test")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = []
expected_y = []
for x in range(100):
expected_x.append([x])
y = np.random.random_sample(10)
expected_y.append([y])
mydataset.add_result({"x": x, "y": y})
shadow_ds = make_shadow_dataset(mydataset)
assert mydataset.get_data('x') == expected_x
assert shadow_ds.get_data('x') == expected_x
y_data = mydataset.get_data('y')
np.testing.assert_allclose(y_data, expected_y)
y_data = shadow_ds.get_data('y')
np.testing.assert_allclose(y_data, expected_y)
def test_add_data_array():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
idps = InterDependencies_(
standalones=(ParamSpecBase("x", "numeric"),
ParamSpecBase("y", "array")))
mydataset = new_data_set("test")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = np.arange(100)
expected_y = []
for x in range(100):
y = np.random.random_sample(10)
expected_y.append(y)
mydataset.add_results([{"x": x, "y": y}])
shadow_ds = make_shadow_dataset(mydataset)
np.testing.assert_array_equal(mydataset.get_parameter_data()['x']['x'], np.array(expected_x))
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['x']['x'], np.array(expected_x))
y_data = mydataset.get_parameter_data()['y']['y']
np.testing.assert_allclose(y_data, expected_y)
y_data = shadow_ds.get_parameter_data()['y']['y']
np.testing.assert_allclose(y_data, expected_y)
def test_adding_too_many_results():
"""
This test really tests the "chunking" functionality of the
insert_many_values function of the sqlite.query_helpers module
"""
dataset = new_data_set("test_adding_too_many_results")
xparam = ParamSpecBase("x", "numeric", label="x parameter",
unit='V')
yparam = ParamSpecBase("y", 'numeric', label='y parameter',
unit='Hz')
idps = InterDependencies_(dependencies={yparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
n_max = qc.SQLiteSettings.limits['MAX_VARIABLE_NUMBER']
vals = np.linspace(0, 1, int(n_max/2)+2)
results = [{'x': val} for val in vals]
dataset.add_results(results)
vals = np.linspace(0, 1, int(n_max/2)+1)
results = [{'x': val, 'y': val} for val in vals]
dataset.add_results(results)
vals = np.linspace(0, 1, n_max*3)
results = [{'x': val} for val in vals]
dataset.add_results(results)
def test_get_data_by_id_order(dataset):
"""
Test that the added values of setpoints end up associated with the correct
setpoint parameter, irrespective of the ordering of those setpoint
parameters
"""
indepA = ParamSpecBase('indep1', "numeric")
indepB = ParamSpecBase('indep2', "numeric")
depAB = ParamSpecBase('depAB', "numeric")
depBA = ParamSpecBase('depBA', "numeric")
idps = InterDependencies_(
dependencies={depAB: (indepA, indepB), depBA: (indepB, indepA)})
dataset.set_interdependencies(idps)
dataset.mark_started()
dataset.add_result({'depAB': 12,
'indep2': 2,
'indep1': 1})
dataset.add_result({'depBA': 21,
'indep2': 2,
'indep1': 1})
dataset.mark_completed()
data = get_data_by_id(dataset.run_id)
data_dict = {el['name']: el['data'] for el in data[0]}
assert data_dict['indep1'] == 1
assert data_dict['indep2'] == 2
data_dict = {el['name']: el['data'] for el in data[1]}
assert data_dict['indep1'] == 1
assert data_dict['indep2'] == 2
def standalone_parameters_dataset(dataset):
n_params = 3
n_rows = 10**3
params_indep = [
ParamSpecBase(f'param_{i}', 'numeric', label=f'param_{i}', unit='V')
for i in range(n_params)
]
param_dep = ParamSpecBase(f'param_{n_params}',
'numeric',
label=f'param_{n_params}',
unit='Ohm')
params_all = params_indep + [param_dep]
idps = InterDependencies_(
dependencies={param_dep: tuple(params_indep[0:1])},
standalones=tuple(params_indep[1:]))
dataset.set_interdependencies(idps)
dataset.mark_started()
dataset.add_results([{
p.name: int(n_rows * 10 * pn + i)
for pn, p in enumerate(params_all)
} for i in range(n_rows)])
dataset.mark_completed()
yield dataset
def _from_dict(cls, ser: Dict[str, Any]) -> 'InterDependencies_':
"""
Construct an InterDependencies_ object from a dictionary
representation of such an object
"""
params = ser['parameters']
deps = {}
for key, value in ser['dependencies'].items():
deps_key = ParamSpecBase._from_dict(params[key])
deps_vals = tuple(
ParamSpecBase._from_dict(params[val]) for val in value)
deps.update({deps_key: deps_vals})
inffs = {}
for key, value in ser['inferences'].items():
inffs_key = ParamSpecBase._from_dict(params[key])
inffs_vals = tuple(
ParamSpecBase._from_dict(params[val]) for val in value)
inffs.update({inffs_key: inffs_vals})
stdls = tuple(
ParamSpecBase._from_dict(params[ps_id])
for ps_id in ser['standalones'])
return cls(dependencies=deps, inferences=inffs, standalones=stdls)
def test_write_data_to_text_file_length_exception(tmp_path):
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", 'numeric')
yparam = ParamSpecBase("y", 'numeric')
zparam = ParamSpecBase("z", 'numeric')
idps = InterDependencies_(dependencies={
yparam: (xparam, ),
zparam: (xparam, )
})
dataset.set_interdependencies(idps)
dataset.mark_started()
results1 = [{'x': 0, 'y': 1}]
results2 = [{'x': 0, 'z': 2}]
results3 = [{'x': 1, 'z': 3}]
dataset.add_results(results1)
dataset.add_results(results2)
dataset.add_results(results3)
dataset.mark_completed()
temp_dir = str(tmp_path)
with pytest.raises(Exception, match='different length'):
dataset.write_data_to_text_file(path=temp_dir,
single_file=True,
single_file_name='yz')
def some_paramspecbases():
psb1 = ParamSpecBase('psb1', paramtype='text', label='blah', unit='')
psb2 = ParamSpecBase('psb2', paramtype='array', label='', unit='V')
psb3 = ParamSpecBase('psb3', paramtype='array', label='', unit='V')
psb4 = ParamSpecBase('psb4', paramtype='numeric', label='number', unit='')
return (psb1, psb2, psb3, psb4)
def _make_simple_run_describer():
x = ParamSpecBase("x", "numeric")
t = ParamSpecBase("t", "numeric")
y = ParamSpecBase("y", "numeric")
paramtree = {y: (x, t)}
interdependencies = InterDependencies_(dependencies=paramtree)
rundescriber = RunDescriber(interdependencies)
yield rundescriber
def _make_mock_empty_dataset():
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", "numeric")
yparam = ParamSpecBase("y", "numeric")
zparam = ParamSpecBase("z", "numeric")
idps = InterDependencies_(dependencies={yparam: (xparam,), zparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
dataset.mark_completed()
return dataset
def _make_mock_dataset_complex():
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", "numeric")
yparam = ParamSpecBase("y", "complex")
idps = InterDependencies_(dependencies={yparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
results = [{"x": 0, "y": 1 + 1j}]
dataset.add_results(results)
dataset.mark_completed()
return dataset
def _make_mock_dataset_label_unit():
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", "numeric", label="x label", unit="x unit")
yparam = ParamSpecBase("y", "numeric", label="y label", unit="y unit")
zparam = ParamSpecBase("z", "numeric", label="z label", unit="z unit")
idps = InterDependencies_(dependencies={yparam: (xparam,), zparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
results = [{"x": 0, "y": 1, "z": 2}]
dataset.add_results(results)
dataset.mark_completed()
return dataset
def _make_mock_dataset_nonunique_index():
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", 'numeric')
yparam = ParamSpecBase("y", 'numeric')
zparam = ParamSpecBase("z", 'numeric')
idps = InterDependencies_(
dependencies={yparam: (xparam,), zparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
results = [{'x': 0, 'y': 1, 'z': 2}, {'x': 0, 'y': 1, 'z': 2}]
dataset.add_results(results)
dataset.mark_completed()
return dataset
def test_numpy_types(bg_writing):
"""
Test that we can save numpy types in the data set
"""
p = ParamSpecBase(name="p", paramtype="numeric")
test_set = qc.new_data_set("test-dataset")
test_set.set_interdependencies(InterDependencies_(standalones=(p, )))
test_set.mark_started(start_bg_writer=bg_writing)
idps = InterDependencies_(standalones=(p, ))
data_saver = DataSaver(dataset=test_set,
write_period=0,
interdeps=idps,
write_in_background=bg_writing)
dtypes = [
np.int8, np.int16, np.int32, np.int64, np.float16, np.float32,
np.float64
]
for dtype in dtypes:
data_saver.add_result(("p", dtype(2)))
data_saver.flush_data_to_database()
test_set.mark_completed()
data = test_set.get_parameter_data("p")["p"]["p"]
expected_data = np.ones(len(dtypes))
expected_data[:] = 2
np.testing.assert_array_equal(data, expected_data)
def test_string_with_wrong_paramtype_via_datasaver(experiment):
"""
Test that it is not possible to add a string value for a non-text
parameter via DataSaver object
"""
p = ParamSpecBase("p", "numeric")
test_set = qc.new_data_set("test-dataset")
idps = InterDependencies_(standalones=(p, ))
test_set.set_interdependencies(idps)
test_set.mark_started()
idps = InterDependencies_(standalones=(p, ))
data_saver = DataSaver(dataset=test_set,
write_period=0,
interdeps=idps,
write_in_background=False)
try:
msg = re.escape('Parameter p is of type "numeric", but got a '
"result of type <U9 (some text).")
with pytest.raises(ValueError, match=msg):
data_saver.add_result(("p", "some text"))
finally:
data_saver.dataset.conn.close()
def test_timestamps(experiment):
ds = DataSetInMem._create_new_run(name="foo")
assert ds.run_timestamp() is None
assert ds.run_timestamp_raw is None
assert ds.completed_timestamp() is None
assert ds.completed_timestamp_raw is None
pss: List[ParamSpecBase] = []
for n in range(3):
pss.append(ParamSpecBase(f"ps{n}", paramtype="numeric"))
idps = InterDependencies_(dependencies={pss[0]: (pss[1], pss[2])})
ds.prepare(interdeps=idps, snapshot={})
assert ds.run_timestamp() is not None
assert ds.run_timestamp_raw is not None
assert ds.completed_timestamp() is None
assert ds.completed_timestamp_raw is None
ds.mark_completed()
assert ds.run_timestamp() is not None
assert ds.run_timestamp_raw is not None
assert ds.completed_timestamp() is not None
assert ds.completed_timestamp_raw is not None
ds.mark_completed()
def test_dependent_parameters():
pss: List[ParamSpecBase] = []
for n in range(5):
pss.append(ParamSpecBase(f'ps{n}', paramtype='numeric'))
idps = InterDependencies_(dependencies={pss[0]: (pss[1], pss[2])})
ds = DataSet(specs=idps)
assert ds.dependent_parameters == (pss[0],)
idps = InterDependencies_(dependencies={pss[0]: (pss[1], pss[2])},
standalones=(pss[3], pss[4]))
ds = DataSet(specs=idps)
assert ds.dependent_parameters == (pss[0],)
idps = InterDependencies_(dependencies={pss[0]: (pss[1], pss[2]),
pss[3]: (pss[4],)})
ds = DataSet(specs=idps)
assert ds.dependent_parameters == (pss[0], pss[3])
idps = InterDependencies_(dependencies={pss[3]: (pss[1], pss[2]),
pss[0]: (pss[4],)})
ds = DataSet(specs=idps)
assert ds.dependent_parameters == (pss[3], pss[0])
def test_numpy_types():
"""
Test that we can save numpy types in the data set
"""
p = ParamSpecBase(name="p", paramtype="numeric")
test_set = qc.new_data_set("test-dataset")
test_set.set_interdependencies(InterDependencies_(standalones=(p, )))
test_set.mark_started()
idps = InterDependencies_(standalones=(p, ))
data_saver = DataSaver(dataset=test_set, write_period=0, interdeps=idps)
dtypes = [
np.int8, np.int16, np.int32, np.int64, np.float16, np.float32,
np.float64
]
for dtype in dtypes:
data_saver.add_result(("p", dtype(2)))
data_saver.flush_data_to_database()
data = test_set.get_data("p")
assert data == [[2] for _ in range(len(dtypes))]
def test_saving_numeric_values_as_text(numeric_type):
"""
Test the saving numeric values into 'text' parameter raises an exception
"""
p = ParamSpecBase("p", "text")
test_set = qc.new_data_set("test-dataset")
test_set.set_interdependencies(InterDependencies_(standalones=(p, )))
test_set.mark_started()
idps = InterDependencies_(standalones=(p, ))
data_saver = DataSaver(dataset=test_set, write_period=0, interdeps=idps)
try:
value = numeric_type(2)
gottype = np.array(value).dtype
msg = re.escape(f'Parameter {p.name} is of type '
f'"{p.type}", but got a result of '
f'type {gottype} ({value}).')
with pytest.raises(ValueError, match=msg):
data_saver.add_result((p.name, value))
finally:
data_saver.dataset.conn.close()
def test_write_data_to_text_file_save():
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", 'numeric')
yparam = ParamSpecBase("y", 'numeric')
idps = InterDependencies_(dependencies={yparam: (xparam, )})
dataset.set_interdependencies(idps)
dataset.mark_started()
results = [{'x': 0, 'y': 1}]
dataset.add_results(results)
dataset.mark_completed()
with tempfile.TemporaryDirectory() as temp_dir:
dataset.write_data_to_text_file(path=temp_dir)
assert os.listdir(temp_dir) == ['y.dat']
with open(temp_dir + "//y.dat") as f:
assert f.readlines() == ['0\t1\n']
def test_write_data_to_text_file_save(tmp_path_factory):
dataset = new_data_set("dataset")
xparam = ParamSpecBase("x", 'numeric')
yparam = ParamSpecBase("y", 'numeric')
idps = InterDependencies_(dependencies={yparam: (xparam,)})
dataset.set_interdependencies(idps)
dataset.mark_started()
results = [{'x': 0, 'y': 1}]
dataset.add_results(results)
dataset.mark_completed()
path = str(tmp_path_factory.mktemp("write_data_to_text_file_save"))
dataset.write_data_to_text_file(path=path)
assert os.listdir(path) == ['y.dat']
with open(os.path.join(path, "y.dat")) as f:
assert f.readlines() == ['0\t1\n']
class TestGetData:
x = ParamSpecBase("x", paramtype='numeric')
n_vals = 5
xvals = list(range(n_vals))
# this is the format of how data is returned by DataSet.get_data
# which means "a list of table rows"
xdata = [[x] for x in xvals]
@pytest.fixture(autouse=True)
def ds_with_vals(self, dataset):
"""
This fixture creates a DataSet with values that is to be used by all
the tests in this class
"""
idps = InterDependencies_(standalones=(self.x, ))
dataset.set_interdependencies(idps)
dataset.mark_started()
for xv in self.xvals:
dataset.add_result({self.x.name: xv})
return dataset
@pytest.mark.parametrize(
("start", "end", "expected"),
[
# test without start and end
(None, None, xdata),
# test for start only
(0, None, xdata),
(2, None, xdata[(2 - 1):]),
(-2, None, xdata),
(n_vals, None, xdata[(n_vals - 1):]),
(n_vals + 1, None, []),
(n_vals + 2, None, []),
# test for end only
(None, 0, []),
(None, 2, xdata[:2]),
(None, -2, []),
(None, n_vals, xdata),
(None, n_vals + 1, xdata),
(None, n_vals + 2, xdata),
# test for start and end
(0, 0, []),
(1, 1, [xdata[1 - 1]]),
(2, 1, []),
(2, 0, []),
(1, 0, []),
(n_vals, n_vals, [xdata[n_vals - 1]]),
(n_vals, n_vals - 1, []),
(2, 4, xdata[(2 - 1):4]),
],
)
def test_get_data_with_start_and_end_args(self, ds_with_vals, start, end,
expected):
assert expected == ds_with_vals.get_data(self.x, start=start, end=end)
def _register_parameter(self: T, name: str,
label: Optional[str],
unit: Optional[str],
setpoints: Optional[setpoints_type],
basis: Optional[setpoints_type],
paramtype: str) -> T:
"""
Update the interdependencies object with a new group
"""
parameter: Optional[ParamSpecBase]
try:
parameter = self._interdeps[name]
except KeyError:
parameter = None
paramspec = ParamSpecBase(name=name,
paramtype=paramtype,
label=label,
unit=unit)
# We want to allow the registration of the exact same parameter twice,
# the reason being that e.g. two ArrayParameters could share the same
# setpoint parameter, which would then be registered along with each
# dependent (array)parameter
if parameter is not None and parameter != paramspec:
raise ValueError("Parameter already registered "
"in this Measurement.")
if setpoints is not None:
sp_strings = [str(sp) for sp in setpoints]
else:
sp_strings = []
if basis is not None:
bs_strings = [str(bs) for bs in basis]
else:
bs_strings = []
# get the ParamSpecBases
depends_on, inf_from = self._paramspecbase_from_strings(name,
sp_strings,
bs_strings)
if depends_on:
self._interdeps = self._interdeps.extend(
dependencies={paramspec: depends_on})
if inf_from:
self._interdeps = self._interdeps.extend(
inferences={paramspec: inf_from})
if not(depends_on or inf_from):
self._interdeps = self._interdeps.extend(standalones=(paramspec,))
log.info(f'Registered {name} in the Measurement.')
return self
def test_basic_subscription(dataset, basic_subscriber):
xparam = ParamSpecBase(name='x',
paramtype='numeric',
label='x parameter',
unit='V')
yparam = ParamSpecBase(name='y',
paramtype='numeric',
label='y parameter',
unit='Hz')
idps = InterDependencies_(dependencies={yparam: (xparam, )})
dataset.set_interdependencies(idps)
dataset.mark_started()
sub_id = dataset.subscribe(basic_subscriber,
min_wait=0,
min_count=1,
state={})
assert len(dataset.subscribers) == 1
assert list(dataset.subscribers.keys()) == [sub_id]
expected_state = {}
for x in range(10):
y = -x**2
dataset.add_results([{'x': x, 'y': y}])
expected_state[x + 1] = [(x, y)]
@retry_until_does_not_throw(exception_class_to_expect=AssertionError,
delay=0.5,
tries=10)
def assert_expected_state():
assert dataset.subscribers[sub_id].state == expected_state
assert_expected_state()
dataset.unsubscribe(sub_id)
assert len(dataset.subscribers) == 0
assert list(dataset.subscribers.keys()) == []
# Ensure the trigger for the subscriber has been removed from the database
get_triggers_sql = "SELECT * FROM sqlite_master WHERE TYPE = 'trigger';"
triggers = atomic_transaction(dataset.conn, get_triggers_sql).fetchall()
assert len(triggers) == 0
def test_missing_keys(dataset):
"""
Test that we can now have partial results with keys missing. This is for
example handy when having an interleaved 1D and 2D sweep.
"""
x = ParamSpecBase("x", paramtype='numeric')
y = ParamSpecBase("y", paramtype='numeric')
a = ParamSpecBase("a", paramtype='numeric')
b = ParamSpecBase("b", paramtype='numeric')
idps = InterDependencies_(dependencies={a: (x,), b: (x, y)})
dataset.set_interdependencies(idps)
dataset.mark_started()
def fa(xv):
return xv + 1
def fb(xv, yv):
return xv + 2 - yv * 3
results = []
xvals = [1, 2, 3]
yvals = [2, 3, 4]
for xv in xvals:
results.append({"x": xv, "a": fa(xv)})
for yv in yvals:
results.append({"x": xv, "y": yv, "b": fb(xv, yv)})
dataset.add_results(results)
loaded_data = dataset.get_parameter_data()
np.testing.assert_array_equal(loaded_data['a']['x'],
np.array(xvals))
np.testing.assert_array_equal(loaded_data['a']['a'],
np.array([fa(xv) for xv in xvals]))
np.testing.assert_array_equal(loaded_data['b']['x'],
np.repeat(np.array(xvals), 3))
np.testing.assert_array_equal(loaded_data['b']['y'],
np.tile(np.array(yvals), 3))
np.testing.assert_array_equal(loaded_data['b']['b'],
np.array([fb(xv, yv) for xv in xvals for yv in yvals]))
def test_add_data_1d():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
psx = ParamSpecBase("x", "numeric")
psy = ParamSpecBase("y", "numeric")
idps = InterDependencies_(dependencies={psy: (psx, )})
mydataset = new_data_set("test-dataset")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = []
expected_y = []
for x in range(100):
expected_x.append(x)
y = 3 * x + 10
expected_y.append(y)
mydataset.add_results([{"x": x, "y": y}])
shadow_ds = make_shadow_dataset(mydataset)
np.testing.assert_array_equal(mydataset.get_parameter_data()['y']['x'],
expected_x)
np.testing.assert_array_equal(mydataset.get_parameter_data()['y']['y'],
expected_y)
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['y']['x'],
expected_x)
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['y']['y'],
expected_y)
assert mydataset.completed is False
mydataset.mark_completed()
assert mydataset.completed is True
with pytest.raises(CompletedError):
mydataset.add_results([{'y': 500}])
with pytest.raises(CompletedError):
mydataset.add_results([{'x': 5}])
def test_missing_keys(dataset):
"""
Test that we can now have partial results with keys missing. This is for
example handy when having an interleaved 1D and 2D sweep.
"""
x = ParamSpecBase("x", paramtype='numeric')
y = ParamSpecBase("y", paramtype='numeric')
a = ParamSpecBase("a", paramtype='numeric')
b = ParamSpecBase("b", paramtype='numeric')
idps = InterDependencies_(dependencies={a: (x, ), b: (x, y)})
dataset.set_interdependencies(idps)
dataset.mark_started()
def fa(xv):
return xv + 1
def fb(xv, yv):
return xv + 2 - yv * 3
results = []
xvals = [1, 2, 3]
yvals = [2, 3, 4]
for xv in xvals:
results.append({"x": xv, "a": fa(xv)})
for yv in yvals:
results.append({"x": xv, "y": yv, "b": fb(xv, yv)})
dataset.add_results(results)
assert dataset.get_values("x") == [[r["x"]] for r in results]
assert dataset.get_values("y") == [[r["y"]] for r in results if "y" in r]
assert dataset.get_values("a") == [[r["a"]] for r in results if "a" in r]
assert dataset.get_values("b") == [[r["b"]] for r in results if "b" in r]
assert dataset.get_setpoints("a")['x'] == [[xv] for xv in xvals]
tmp = [list(t) for t in zip(*(itertools.product(xvals, yvals)))]
expected_setpoints = [[[v] for v in vals] for vals in tmp]
assert dataset.get_setpoints("b")['x'] == expected_setpoints[0]
assert dataset.get_setpoints("b")['y'] == expected_setpoints[1]
