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]