def test_string(experiment): """ Test that we can save text into database via Measurement API """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) meas.register_parameter(p, paramtype='text') with meas.run() as datasaver: datasaver.add_result((p, "some text")) test_set = load_by_id(datasaver.run_id) assert test_set.get_data("p") == [["some text"]]
def test_datasaver_1d(experiment, DAC, DMM, caplog, n_points): meas = Measurement() meas.register_parameter(DAC.ch1) meas.register_parameter(DMM.v1, setpoints=(DAC.ch1,)) n_points_expected = 5 meas.set_shapes({DMM.v1.full_name: (n_points_expected,)}) with meas.run() as datasaver: for set_v in np.linspace(0, 1, n_points): DAC.ch1() datasaver.add_result((DAC.ch1, set_v), (DMM.v1, DMM.v1())) ds = datasaver.dataset caplog.clear() data = ds.get_parameter_data() for dataarray in data[DMM.v1.full_name].values(): assert dataarray.shape == (n_points,) if n_points == n_points_expected: assert len(caplog.record_tuples) == 0 elif n_points > n_points_expected: assert len(caplog.record_tuples) == 2 exp_module = "qcodes.dataset.sqlite.queries" exp_level = logging.WARNING exp_msg = ("Tried to set data shape for {} in " "dataset {} " "from metadata when loading " "but found inconsistent lengths {} and {}") assert caplog.record_tuples[0] == (exp_module, exp_level, exp_msg.format(DMM.v1.full_name, DMM.v1.full_name, n_points, n_points_expected)) assert caplog.record_tuples[1] == (exp_module, exp_level, exp_msg.format(DAC.ch1.full_name, DMM.v1.full_name, n_points, n_points_expected))
def do0d(*param_meas: Union[_BaseParameter, Callable[[], None]], do_plot: bool = True) -> AxesTupleListWithRunId: """ Perform a measurement of a single parameter. This is probably most useful for an ArrayParamter that already returns an array of data points Args: *param_meas: Parameter(s) to measure at each step or functions that will be called at each step. The function should take no arguments. The parameters and functions are called in the order they are supplied. do_plot: should png and pdf versions of the images be saved after the run. Returns: The run_id of the DataSet created """ meas = Measurement() output = [] for parameter in param_meas: meas.register_parameter(parameter) output.append([parameter, None]) with meas.run() as datasaver: for i, parameter in enumerate(param_meas): if isinstance(parameter, _BaseParameter): output[i][1] = parameter.get() elif callable(parameter): parameter() datasaver.add_result(*output) dataid = datasaver.run_id if do_plot is True: ax, cbs = _save_image(datasaver) else: ax = None, cbs = None return dataid, ax, cbs
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 _create_measurement(self): """ Creates a QCoDeS Measurement object. This controls the saving of data by registering QCoDeS Parameter objects, which this function does. Registers all 'tracked' parameters, Returns the measurement object. This function will register only parameters that are followed BEFORE this function is called. """ # First, create time parameter self.meas = Measurement() self.meas.register_custom_parameter('time', label='Time', unit='s') # Check if we are 'setting' a parameter, and register it if self.set_param is not None: self.meas.register_parameter(self.set_param) # Register all parameters we are following for p in self._params: self.meas.register_parameter(p) return self.meas
def store_array_to_database_alt(meas: Measurement, array: DataArray) -> int: dims = len(array.shape) if dims == 2: outer_data = np.empty(array.shape[1]) with meas.run() as datasaver: for index1, i in enumerate(array.set_arrays[0]): outer_data[:] = i datasaver.add_result( (array.set_arrays[0].array_id, outer_data), (array.set_arrays[1].array_id, array.set_arrays[1][index1, :]), (array.array_id, array[index1, :])) elif dims == 1: with meas.run() as datasaver: for index, i in enumerate(array.set_arrays[0]): datasaver.add_result((array.set_arrays[0].array_id, i), (array.array_id, array[index])) else: raise NotImplementedError( 'The exporter only currently handles 1 and 2 Dimentional data') return datasaver.run_id
def _make_meas_with_registered_param_complex(experiment, DAC, complex_num_instrument): meas = Measurement() meas.register_parameter(DAC.ch1) meas.register_parameter(complex_num_instrument.complex_num, setpoints=[DAC.ch1]) yield meas
def do0d(*param_meas: ParamMeasT, write_period: Optional[float] = None, do_plot: bool = True) -> AxesTupleListWithDataSet: """ Perform a measurement of a single parameter. This is probably most useful for an ArrayParameter that already returns an array of data points Args: *param_meas: Parameter(s) to measure at each step or functions that will be called at each step. The function should take no arguments. The parameters and functions are called in the order they are supplied. write_period: The time after which the data is actually written to the database. do_plot: should png and pdf versions of the images be saved after the run. Returns: The QCoDeS dataset. """ meas = Measurement() measured_parameters = tuple(param for param in param_meas if isinstance(param, _BaseParameter)) try: shapes: Shapes = detect_shape_of_measurement(measured_parameters, ) except TypeError: LOG.exception(f"Could not detect shape of {measured_parameters} " f"falling back to unknown shape.") shapes = None _register_parameters(meas, param_meas, shapes=shapes) _set_write_period(meas, write_period) with meas.run() as datasaver: datasaver.add_result(*_process_params_meas(param_meas)) dataset = datasaver.dataset return _handle_plotting(dataset, do_plot)
def test_snapshot_creation_for_types_not_supported_by_builtin_json(experiment): """ Test that `Measurement`/`Runner`/`DataSaver` infrastructure successfully dumps station snapshots in JSON format in cases when the snapshot contains data of types that are not supported by python builtin `json` module, for example, numpy scalars. """ p1 = ManualParameter('p_np_int32', initial_value=numpy.int32(5)) p2 = ManualParameter('p_np_float16', initial_value=numpy.float16(5.0)) p3 = ManualParameter('p_np_array', initial_value=numpy.meshgrid((1, 2), (3, 4))) p4 = ManualParameter('p_np_bool', initial_value=numpy.bool_(False)) station = Station(p1, p2, p3, p4) measurement = Measurement(experiment, station) # we need at least 1 parameter to be able to run the measurement measurement.register_custom_parameter('dummy') with measurement.run() as data_saver: # we do this in order to create a snapshot of the station and add it # to the database pass snapshot = data_saver.dataset.snapshot assert 5 == snapshot['station']['parameters']['p_np_int32']['value'] assert 5 == snapshot['station']['parameters']['p_np_int32']['raw_value'] assert 5.0 == snapshot['station']['parameters']['p_np_float16']['value'] assert 5.0 == snapshot['station']['parameters']['p_np_float16'][ 'raw_value'] lst = [[[1, 2], [1, 2]], [[3, 3], [4, 4]]] assert lst == snapshot['station']['parameters']['p_np_array']['value'] assert lst == snapshot['station']['parameters']['p_np_array']['raw_value'] assert False is snapshot['station']['parameters']['p_np_bool']['value'] assert False is snapshot['station']['parameters']['p_np_bool']['raw_value']
def test_list_of_strings(experiment): """ Test saving list of strings via DataSaver """ p_values = ["X_Y", "X_X", "X_I", "I_I"] list_of_strings = list(np.random.choice(p_values, (10,))) p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='X_Y') meas = Measurement(experiment) meas.register_parameter(p, paramtype='text') with meas.run() as datasaver: datasaver.add_result((p, list_of_strings)) test_set = load_by_id(datasaver.run_id) try: assert [[item] for item in list_of_strings] == test_set.get_data("p") finally: test_set.conn.close()
def test_string_with_wrong_paramtype(experiment): """ Test that an exception occurs when saving string data if when registering a string parameter the paramtype was not set to 'text' """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) # intentionally forget `paramtype='text'`, so that the default 'numeric' # is used, and an exception is raised later meas.register_parameter(p) with meas.run() as datasaver: msg = "It is not possible to save a string value for parameter 'p' " \ "because its type class is 'numeric', not 'text'." with pytest.raises(ValueError, match=msg): datasaver.add_result((p, "some text"))
def test_string_with_wrong_paramtype(experiment): """ Test that an exception occurs when saving string data if when registering a string parameter the paramtype was not set to 'text' """ p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None, set_cmd=None, initial_value='some text') meas = Measurement(experiment) # intentionally forget `paramtype='text'`, so that the default 'numeric' # is used, and an exception is raised later meas.register_parameter(p) with meas.run() as datasaver: msg = re.escape('Parameter p is of type "numeric", but got a ' "result of type <U9 (some text).") with pytest.raises(ValueError, match=msg): datasaver.add_result((p, "some text"))
def test_column_mismatch(two_empty_temp_db_connections, some_interdeps, inst): """ Test insertion of runs with no metadata and no snapshot into a DB already containing a run that has both """ source_conn, target_conn = two_empty_temp_db_connections source_path = path_to_dbfile(source_conn) target_path = path_to_dbfile(target_conn) target_exp = Experiment(conn=target_conn) # Set up measurement scenario station = Station(inst) meas = Measurement(exp=target_exp, station=station) meas.register_parameter(inst.back) meas.register_parameter(inst.plunger) meas.register_parameter(inst.cutter, setpoints=(inst.back, inst.plunger)) with meas.run() as datasaver: for back_v in [1, 2, 3]: for plung_v in [-3, -2.5, 0]: datasaver.add_result((inst.back, back_v), (inst.plunger, plung_v), (inst.cutter, back_v+plung_v)) datasaver.dataset.add_metadata('meta_tag', 'meta_value') Experiment(conn=source_conn) source_ds = DataSet(conn=source_conn) source_ds.set_interdependencies(some_interdeps[1]) source_ds.mark_started() source_ds.add_results([{name: 2.1 for name in some_interdeps[1].names}]) source_ds.mark_completed() extract_runs_into_db(source_path, target_path, 1) # compare target_copied_ds = DataSet(conn=target_conn, run_id=2) assert target_copied_ds.the_same_dataset_as(source_ds)
def test_datasaver_multidimarrayparameter_as_array(SpectrumAnalyzer, bg_writing): array_param = SpectrumAnalyzer.multidimspectrum meas = Measurement() meas.register_parameter(array_param, paramtype='array') assert len(meas.parameters) == 4 inserted_data = array_param.get() with meas.run(write_in_background=bg_writing) as datasaver: datasaver.add_result((array_param, inserted_data)) expected_shape = (1, 100, 50, 20) datadicts = _get_data_from_ds(datasaver.dataset) assert len(datadicts) == 1 for datadict_list in datadicts: assert len(datadict_list) == 4 for datadict in datadict_list: datadict['data'].shape = (np.prod(expected_shape), ) if datadict['name'] == "dummy_SA_Frequency0": temp_data = np.linspace(array_param.start, array_param.stop, array_param.npts[0]) expected_data = np.repeat( temp_data, expected_shape[2] * expected_shape[3]) if datadict['name'] == "dummy_SA_Frequency1": temp_data = np.linspace(array_param.start, array_param.stop, array_param.npts[1]) expected_data = np.tile( np.repeat(temp_data, expected_shape[3]), expected_shape[1]) if datadict['name'] == "dummy_SA_Frequency2": temp_data = np.linspace(array_param.start, array_param.stop, array_param.npts[2]) expected_data = np.tile(temp_data, expected_shape[1] * expected_shape[2]) if datadict['name'] == "dummy_SA_multidimspectrum": expected_data = inserted_data.ravel() assert_allclose(datadict['data'], expected_data)
def test_measurement_name(experiment, DAC, DMM): fmt = experiment.format_string exp_id = experiment.exp_id name = 'yolo' meas = Measurement() meas.name = name meas.register_parameter(DAC.ch1) meas.register_parameter(DMM.v1, setpoints=[DAC.ch1]) with meas.run() as datasaver: run_id = datasaver.run_id expected_name = fmt.format(name, exp_id, run_id) assert datasaver.dataset.table_name == expected_name
def test_cache_1d(experiment, DAC, DMM, n_points, bg_writing, channel_array_instrument, setpoints_type): setpoints_param, setpoints_values = _prepare_setpoints_1d( DAC, channel_array_instrument, n_points, setpoints_type) meas = Measurement() meas.register_parameter(setpoints_param) meas_parameters = ( DMM.v1, channel_array_instrument.A.dummy_multi_parameter, channel_array_instrument.A.dummy_scalar_multi_parameter, channel_array_instrument.A.dummy_2d_multi_parameter, channel_array_instrument.A.dummy_2d_multi_parameter_2, channel_array_instrument.A.dummy_array_parameter, channel_array_instrument.A.dummy_complex_array_parameter, channel_array_instrument.A.dummy_complex, channel_array_instrument.A.dummy_parameter_with_setpoints, channel_array_instrument.A.dummy_parameter_with_setpoints_complex, ) channel_array_instrument.A.dummy_start(0) channel_array_instrument.A.dummy_stop(10) channel_array_instrument.A.dummy_n_points(10) for param in meas_parameters: meas.register_parameter(param, setpoints=(setpoints_param, )) with meas.run(write_in_background=bg_writing) as datasaver: dataset = datasaver.dataset _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data()) for i, v in enumerate(setpoints_values): setpoints_param.set(v) meas_vals = [(param, param.get()) for param in meas_parameters[:-2]] meas_vals += expand_setpoints_helper(meas_parameters[-2]) meas_vals += expand_setpoints_helper(meas_parameters[-1]) datasaver.add_result((setpoints_param, v), *meas_vals) datasaver.flush_data_to_database(block=True) data = dataset.cache.data() _assert_parameter_data_is_identical(dataset.get_parameter_data(), data) _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data()) assert dataset.cache._loaded_from_completed_ds is True _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data())
def test_cache_1d_every_other_point(experiment, DAC, DMM, n_points, bg_writing, channel_array_instrument, setpoints_type, in_memory_cache): setpoints_param, setpoints_values = _prepare_setpoints_1d(DAC, channel_array_instrument, n_points, setpoints_type) meas = Measurement() meas.register_parameter(setpoints_param) meas_parameters = (DMM.v1, channel_array_instrument.A.temperature, channel_array_instrument.B.temperature ) for param in meas_parameters: meas.register_parameter(param, setpoints=(setpoints_param,)) with meas.run( write_in_background=bg_writing, in_memory_cache=in_memory_cache ) as datasaver: dataset = datasaver.dataset _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data()) for i, v in enumerate(setpoints_values): setpoints_param.set(v) meas_vals = [(param, param.get()) for param in meas_parameters] if i % 2 == 0: datasaver.add_result((setpoints_param, v), *meas_vals) else: datasaver.add_result((setpoints_param, v), *meas_vals[0:2]) datasaver.flush_data_to_database(block=True) data = dataset.cache.data() assert len(data['dummy_channel_inst_ChanA_temperature']['dummy_channel_inst_ChanA_temperature']) == i + 1 assert len(data['dummy_channel_inst_ChanB_temperature']['dummy_channel_inst_ChanB_temperature']) == i//2 + 1 _assert_parameter_data_is_identical(dataset.get_parameter_data(), data) _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data()) if in_memory_cache is False: assert dataset.cache._loaded_from_completed_ds is True assert dataset.completed is True assert dataset.cache.live is in_memory_cache _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data())
def setup(self, bench_param): # Init DB self.tmpdir = tempfile.mkdtemp() qcodes.config["core"]["db_location"] = os.path.join(self.tmpdir, 'temp.db') qcodes.config["core"]["db_debug"] = False initialise_database() # Create experiment self.experiment = new_experiment("test-experiment", sample_name="test-sample") # Create measurement meas = Measurement(self.experiment) x1 = ManualParameter('x1') x2 = ManualParameter('x2') x3 = ManualParameter('x3') y1 = ManualParameter('y1') y2 = ManualParameter('y2') meas.register_parameter(x1) meas.register_parameter(x2) meas.register_parameter(x3) meas.register_parameter(y1, setpoints=[x1, x2, x3]) meas.register_parameter(y2, setpoints=[x1, x2, x3]) self.parameters = [x1, x2, x3, y1, y2] # Create the Runner context manager self.runner = meas.run() # Enter Runner and create DataSaver self.datasaver = self.runner.__enter__() # Create values for parameters for _ in range(len(self.parameters)): self.values.append(np.random.rand(bench_param['n_values']))
def test_cache_2d(experiment, DAC, DMM, n_points_outer, n_points_inner, bg_writing, channel_array_instrument, in_memory_cache): meas = Measurement() meas.register_parameter(DAC.ch1) meas.register_parameter(DAC.ch2) meas_parameters = (DMM.v1, channel_array_instrument.A.dummy_multi_parameter, channel_array_instrument.A.dummy_scalar_multi_parameter, channel_array_instrument.A.dummy_2d_multi_parameter, channel_array_instrument.A.dummy_2d_multi_parameter_2, channel_array_instrument.A.dummy_array_parameter, channel_array_instrument.A.dummy_complex_array_parameter, channel_array_instrument.A.dummy_complex, channel_array_instrument.A.dummy_parameter_with_setpoints, channel_array_instrument.A.dummy_parameter_with_setpoints_complex, ) channel_array_instrument.A.dummy_start(0) channel_array_instrument.A.dummy_stop(10) channel_array_instrument.A.dummy_n_points(10) for param in meas_parameters: meas.register_parameter(param, setpoints=(DAC.ch1, DAC.ch2)) n_rows_written = 0 with meas.run( write_in_background=bg_writing, in_memory_cache=in_memory_cache) as datasaver: dataset = datasaver.dataset _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data()) for v1 in np.linspace(-1, 1, n_points_outer): for v2 in np.linspace(-1, 1, n_points_inner): DAC.ch1.set(v1) DAC.ch2.set(v2) meas_vals = [(param, param.get()) for param in meas_parameters[:-2]] meas_vals += expand_setpoints_helper(meas_parameters[-2]) meas_vals += expand_setpoints_helper(meas_parameters[-1]) datasaver.add_result((DAC.ch1, v1), (DAC.ch2, v2), *meas_vals) datasaver.flush_data_to_database(block=True) n_rows_written += 1 data = dataset.cache.data() _assert_parameter_data_is_identical(dataset.get_parameter_data(), data) _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data())
def test_station_snapshot_during_measurement(experiment, dac, dmm, pass_station): station = Station() station.add_component(dac) station.add_component(dmm, 'renamed_dmm') snapshot_of_station = station.snapshot() if pass_station: measurement = Measurement(experiment, station) else: # in this branch of the `if` we expect that `Measurement` object # will be initialized with `Station.default` which is equal to the # station object that is instantiated above measurement = Measurement(experiment) measurement.register_parameter(dac.ch1) measurement.register_parameter(dmm.v1, setpoints=[dac.ch1]) with measurement.run() as data_saver: data_saver.add_result((dac.ch1, 7), (dmm.v1, 5)) # 1. Test `get_metadata('snapshot')` method json_snapshot_from_dataset = data_saver.dataset.get_metadata('snapshot') snapshot_from_dataset = json.loads(json_snapshot_from_dataset) expected_snapshot = {'station': snapshot_of_station} assert expected_snapshot == snapshot_from_dataset # 2. Test `snapshot_raw` property assert json_snapshot_from_dataset == data_saver.dataset.snapshot_raw # 3. Test `snapshot` property assert expected_snapshot == data_saver.dataset.snapshot
def array_in_str_dataset(experiment, request): meas = Measurement() scalar_param = Parameter('textparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param, paramtype='text') meas.register_parameter(param, setpoints=(scalar_param,), paramtype=request.param) with meas.run() as datasaver: for i in ['A', 'B', 'C']: scalar_param.set(i) datasaver.add_result((scalar_param, scalar_param.get()), (param, param.get())) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def test_datasaver_scalars(experiment, DAC, DMM, set_values, get_values, breakpoint, write_period): no_of_runs = len(experiment) station = qc.Station(DAC, DMM) meas = Measurement(station=station) meas.write_period = write_period assert meas.write_period == write_period meas.register_parameter(DAC.ch1) meas.register_parameter(DMM.v1, setpoints=(DAC.ch1, )) with meas.run() as datasaver: for set_v, get_v in zip(set_values[:breakpoint], get_values[:breakpoint]): datasaver.add_result((DAC.ch1, set_v), (DMM.v1, get_v)) assert datasaver._dataset.number_of_results == 0 sleep(write_period * 1.1) datasaver.add_result((DAC.ch1, set_values[breakpoint]), (DMM.v1, get_values[breakpoint])) assert datasaver.points_written == breakpoint + 1 assert datasaver.run_id == no_of_runs + 1 with meas.run() as datasaver: with pytest.raises(ValueError): datasaver.add_result((DAC.ch2, 1), (DAC.ch2, 2)) with pytest.raises(ValueError): datasaver.add_result((DMM.v1, 0)) # important cleanup, else the following tests will fail qc.Station.default = None
def array_in_scalar_dataset_unrolled(experiment): meas = Measurement() scalar_param = Parameter('scalarparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param) meas.register_parameter(param, setpoints=(scalar_param,), paramtype='numeric') with meas.run() as datasaver: for i in range(1, 10): scalar_param.set(i) datasaver.add_result((scalar_param, scalar_param.get()), (param, param.get())) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def test_run_loaded_experiment(): """ Test that we can resume a measurement after loading by name """ new_experiment("test", "test1") exp_loaded = load_experiment_by_name("test", "test1") meas = Measurement(exp=exp_loaded) meas.register_custom_parameter(name='dummy', paramtype='text') with meas.run(): pass with meas.run(): pass
def test_cache_complex_array_param_in_1d(experiment, DAC, channel_array_instrument, n_points, bg_writing, storage_type, outer_param_type): param = channel_array_instrument.A.dummy_complex_array_parameter meas = Measurement() if outer_param_type == 'numeric': outer_param = DAC.ch1 outer_setpoints = np.linspace(-1, 1, n_points) outer_storage_type = storage_type else: outer_param = channel_array_instrument.A.dummy_text outer_setpoints = ['A', 'B', 'C', 'D'] outer_storage_type = 'text' meas.register_parameter(outer_param, paramtype=outer_storage_type) meas.register_parameter(param, setpoints=(outer_param, ), paramtype=storage_type) array_used = _array_param_used_in_tree(meas) with meas.run(write_in_background=bg_writing) as datasaver: dataset = datasaver.dataset for i, v1 in enumerate(outer_setpoints): datasaver.add_result((outer_param, v1), (param, param.get())) datasaver.flush_data_to_database(block=True) data = dataset.cache.data() n_rows_written = i + 1 if array_used: expected_shape = (n_rows_written, ) + param.shape else: expected_shape = n_rows_written * np.prod(param.shape) assert data[param.full_name][ param.full_name].shape == expected_shape if storage_type != 'array': # with explicit array types the shape is incorrect # https://github.com/QCoDeS/Qcodes/issues/2105 assert data[param.full_name][ outer_param.full_name].shape == expected_shape for setpoint_name in param.setpoint_full_names: assert data[ param.full_name][setpoint_name].shape == expected_shape _assert_parameter_data_is_identical(dataset.get_parameter_data(), data) _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data())
def varlen_array_in_scalar_dataset(experiment): meas = Measurement() scalar_param = Parameter('scalarparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param) meas.register_parameter(param, setpoints=(scalar_param,), paramtype='array') np.random.seed(0) with meas.run() as datasaver: for i in range(1, 10): scalar_param.set(i) param.setpoints = (np.arange(i),) datasaver.add_result((scalar_param, scalar_param.get()), (param, np.random.rand(i))) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def test_datasaver_array_parameters_array(channel_array_instrument, DAC, N, bg_writing): """ Test that storing array parameters inside a loop works as expected """ storage_type = "array" array_param = channel_array_instrument.A.dummy_array_parameter dependency_name = 'dummy_channel_inst_ChanA_array_setpoint_param_this_setpoint' # Now for a real measurement meas = Measurement() meas.register_parameter(DAC.ch1, paramtype='numeric') meas.register_parameter(array_param, setpoints=[DAC.ch1], paramtype=storage_type) assert len(meas.parameters) == 3 M = array_param.shape[0] dac_datapoints = np.linspace(0, 0.01, N) with meas.run(write_in_background=bg_writing) as datasaver: for set_v in dac_datapoints: datasaver.add_result((DAC.ch1, set_v), (array_param, array_param.get())) datadicts = _get_data_from_ds(datasaver.dataset) # one dependent parameter assert len(datadicts) == 1 datadicts = datadicts[0] assert len(datadicts) == len(meas.parameters) for datadict in datadicts: if datadict['name'] == 'dummy_dac_ch1': expected_data = np.repeat(dac_datapoints, M) if datadict['name'] == dependency_name: expected_data = np.tile(np.linspace(5, 9, 5), N) if datadict[ 'name'] == 'dummy_channel_inst_ChanA_dummy_array_parameter': expected_data = np.empty(N * M) expected_data[:] = 2. assert_allclose(datadict['data'], expected_data) assert datadict['data'].shape == (N * M, )
def test_datasaver_multidim_array(experiment, bg_writing): """ Test that inserting multidim parameters as arrays works as expected """ meas = Measurement(experiment) size1 = 10 size2 = 15 data_mapping = { name: i for i, name in zip(range(4), ['x1', 'x2', 'y1', 'y2']) } x1 = qc.ManualParameter('x1') x2 = qc.ManualParameter('x2') y1 = qc.ManualParameter('y1') y2 = qc.ManualParameter('y2') meas.register_parameter(x1, paramtype='array') meas.register_parameter(x2, paramtype='array') meas.register_parameter(y1, setpoints=[x1, x2], paramtype='array') meas.register_parameter(y2, setpoints=[x1, x2], paramtype='array') data = np.random.rand(4, size1, size2) expected = { 'x1': data[0, :, :], 'x2': data[1, :, :], 'y1': data[2, :, :], 'y2': data[3, :, :] } with meas.run(write_in_background=bg_writing) as datasaver: datasaver.add_result( (str(x1), expected['x1']), (str(x2), expected['x2']), (str(y1), expected['y1']), (str(y2), expected['y2'])) datadicts = _get_data_from_ds(datasaver.dataset) assert len(datadicts) == 2 for datadict_list in datadicts: assert len(datadict_list) == 3 for datadict in datadict_list: dataindex = data_mapping[datadict['name']] expected_data = data[dataindex, :, :].ravel() assert_allclose(datadict['data'], expected_data) assert datadict['data'].shape == (size1 * size2, )
def test_setting_write_period(empty_temp_db, wp): new_experiment('firstexp', sample_name='no sample') meas = Measurement() if isinstance(wp, str): with pytest.raises(ValueError): meas.write_period = wp elif wp < 1e-3: with pytest.raises(ValueError): meas.write_period = wp else: meas.write_period = wp assert meas._write_period == wp with meas.run() as datasaver: assert datasaver.write_period == wp
def test_datasaver_array_parameters_channel(channel_array_instrument, DAC, N, storage_type, bg_writing): array_param = channel_array_instrument.A.dummy_array_parameter meas = Measurement() meas.register_parameter(DAC.ch1) meas.register_parameter(array_param, setpoints=[DAC.ch1], paramtype=storage_type) M = array_param.shape[0] with meas.run(write_in_background=bg_writing) as datasaver: for set_v in np.linspace(0, 0.01, N): datasaver.add_result((DAC.ch1, set_v), (array_param, array_param.get())) datadicts = _get_data_from_ds(datasaver.dataset) # one dependent parameter assert len(datadicts) == 1 datadicts = datadicts[0] assert len(datadicts) == len(meas.parameters) for datadict in datadicts: assert datadict['data'].shape == (N * M, )