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] 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 linear_trace(independents, dependents, sweep_param, values, delay=None, exp=None, station=None, fn_before=None, fn_after=None): """ Sweep a single variable over a linear range. Allows other params to be defined as dependent on this param and measured / saved. """ meas = Measurement(exp=exp, station=station) for p in independents: meas.register_parameter(p, ) for p in dependents: meas.register_parameter(p, setpoints=(sweep_param, )) if callable(fn_before): meas.add_before_run(fn_before, ()) if callable(fn_after): meas.add_after_run(fn_after, ()) save_list = [] for p in (independents + dependents): save_list.append([p, None]) with meas.run() as datasaver: for point in values: sweep_param.set(point) if delay is not None: time.sleep(delay) for i, p in enumerate(save_list): save_list[i][1] = p[0].get() datasaver.add_result(*save_list) runid = datasaver.run_id return runid
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 generate_local_run(dbpath: Path) -> str: with initialised_database_at(str(dbpath)): new_experiment(sample_name="fivehundredtest_sample", name="fivehundredtest_name") p1 = Parameter('Voltage', set_cmd=None) p2 = Parameter('Current', get_cmd=np.random.randn) meas = Measurement() meas.register_parameter(p1).register_parameter(p2, setpoints=[p1]) with meas.run() as datasaver: for v in np.linspace(0, 2, 250): p1(v) datasaver.add_result((p1, cast(float, p1())), (p2, cast(float, p2()))) guid = datasaver.dataset.guid datasaver.flush_data_to_database(block=True) return guid
def test_cache_complex_array_param_in_1d(experiment, DAC, channel_array_instrument, n_points, bg_writing, storage_type, outer_param_type, in_memory_cache): 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, in_memory_cache=in_memory_cache) 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 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 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, paramtype=bench_param['paramtype']) meas.register_parameter(x2, paramtype=bench_param['paramtype']) meas.register_parameter(x3, paramtype=bench_param['paramtype']) meas.register_parameter(y1, setpoints=[x1, x2, x3], paramtype=bench_param['paramtype']) meas.register_parameter(y2, setpoints=[x1, x2, x3], paramtype=bench_param['paramtype']) 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_1d_every_other_point(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.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) 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()) assert dataset.cache._loaded_from_completed_ds is True _assert_parameter_data_is_identical(dataset.get_parameter_data(), dataset.cache.data())
def take_buffer_keysight(self): """ takes a frequency sweep, not setting any values on the hardware """ from qcodes import Station station = Station() station.add_component(self.vna) # import pdb; pdb.set_trace() meas = Measurement(station=station) # qcodes measurement # self.vna.points.set(20) self.vna.auto_sweep(False) meas.register_parameter(self.vna.real) meas.register_parameter(self.vna.imaginary) meas.register_parameter(self.vna.magnitude) meas.register_parameter(self.vna.phase) # actually get the data with meas.run( ) as datasaver: # try to run the measurement (? but this doesn't yet write to the database) self.vna.active_trace.set(1) # there are Tr1 and Tr2 # self.vna.traces.tr1.run_sweep() imag = self.vna.imaginary() real = self.vna.real() mag = self.vna.magnitude() phase = self.vna.phase() datasaver.add_result( (self.vna.magnitude, mag), (self.vna.phase, phase), (self.vna.real, real), (self.vna.imaginary, imag)) dataid = datasaver.run_id pd = datasaver.dataset.get_parameter_data() snapshot = datasaver.dataset.snapshot plot_by_id(dataid)
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 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_parameter_data()["p"]["p"] == np.array(["some text"])
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 time_sweep(dependents, event_list, fn_before=None, fn_after=None, exp=None, station=None): """ Takes a list of Events which can run some event and then measure for a period of time. Eg Set vtun to 3v for 5 secs, then bump to 10v for 2 secs, then back to 3v for another 5 secs. """ meas = Measurement(exp=exp, station=station) meas.register_custom_parameter("time", label="Time", unit="S") if callable(fn_before): meas.add_before_run(fn_before, ()) if callable(fn_after): meas.add_after_run(fn_after, ()) for p in dependents: meas.register_parameter(p, setpoints=("time", )) with meas.run() as datasaver: start = time.time() for event in event_list: begin = time.time() if callable(event.fn_before): event.fn_before() time.sleep(0.5) while (time.time() - begin < event.time): save_list = [] save_list.append(["time", time.time() - start]) for p in dependents: save_list.append([p, p.get()]) datasaver.add_result(*save_list) time.sleep(event.step) runid = datasaver.run_id return runid
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_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 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_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_subscribers_called_at_exiting_context_if_queue_is_not_empty( experiment, DAC): """ Upon quitting the "run()" context, verify that in case the queue is not empty, the subscriber's callback is still called on that data. This situation is created by setting the minimum length of the queue to a number that is larger than the number of value written to the dataset. """ def collect_x_vals(results, length, state): """ Collects first elements of results tuples in *state* """ index_of_x = 0 state += [res[index_of_x] for res in results] meas = Measurement(exp=experiment) meas.register_parameter(DAC.ch1) collected_x_vals = [] meas.add_subscriber(collect_x_vals, state=collected_x_vals) given_x_vals = [0, 1, 2, 3] with meas.run() as datasaver: # Set the minimum queue size of the subscriber to more that # the total number of values being added to the dataset; # this way the subscriber callback is not called before # we exit the "run()" context. subscriber = list(datasaver.dataset.subscribers.values())[0] subscriber.min_queue_length = int(len(given_x_vals) + 1) for x in given_x_vals: datasaver.add_result((DAC.ch1, x)) # Verify that the subscriber callback is not called yet assert collected_x_vals == [] # Verify that the subscriber callback is finally called assert collected_x_vals == given_x_vals
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, )
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 save_2Ddata_with_qcodes(data_generator_method, metadata_generator_method): meas = Measurement() meas.register_custom_parameter("v_x", paramtype="numeric", label="voltage x", unit="V") meas.register_custom_parameter("v_y", paramtype="numeric", label="voltage y", unit="V") meas.register_custom_parameter( "current", paramtype="numeric", label="dc current", unit="A", setpoints=("v_x", "v_y"), ) meas.register_custom_parameter( "sensor", paramtype="numeric", label="dc sensor", unit="A", setpoints=("v_x", "v_y"), ) with meas.run() as datasaver: xv, yv, ddot, sensor = data_generator_method() datasaver.add_result(("v_x", xv), ("v_y", yv), ("current", ddot)) datasaver.add_result(("v_x", xv), ("v_y", yv), ("sensor", sensor)) datasaver.dataset.add_metadata("snapshot", json.dumps({})) if metadata_generator_method is not None: nt_metadata, current_label = metadata_generator_method() datasaver.dataset.add_metadata(nt.meta_tag, json.dumps(nt_metadata)) for label, value in current_label.items(): datasaver.dataset.add_metadata(label, value) return datasaver
def test_cache_2d_num_with_multiple_storage_types(experiment, DAC, DMM, n_points_outer, n_points_inner, bg_writing, storage_type, in_memory_cache): meas = Measurement() meas.register_parameter(DAC.ch1, paramtype=storage_type) meas.register_parameter(DAC.ch2, paramtype=storage_type) meas.register_parameter(DMM.v1, setpoints=(DAC.ch1, DAC.ch2), paramtype=storage_type) array_used = _array_param_used_in_tree(meas) 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) datasaver.add_result((DAC.ch1, v1), (DAC.ch2, v2), (DMM.v1, DMM.v1.get())) datasaver.flush_data_to_database(block=True) n_rows_written += 1 data = dataset.cache.data() if array_used: shape = (n_rows_written, 1) else: shape = (n_rows_written, ) assert data[DMM.v1.full_name][DMM.v1.full_name].shape == shape assert data[DMM.v1.full_name][DAC.ch1.full_name].shape == shape _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 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_datasaver_multidim_numeric(experiment, bg_writing): """ Test that inserting multidim parameters as numeric works as expected """ meas = Measurement(experiment) size1 = 10 size2 = 15 x1 = qc.ManualParameter('x1') x2 = qc.ManualParameter('x2') y1 = qc.ManualParameter('y1') y2 = qc.ManualParameter('y2') data_mapping = { name: i for i, name in zip(range(4), ['x1', 'x2', 'y1', 'y2']) } meas.register_parameter(x1, paramtype='numeric') meas.register_parameter(x2, paramtype='numeric') meas.register_parameter(y1, setpoints=[x1, x2], paramtype='numeric') meas.register_parameter(y2, setpoints=[x1, x2], paramtype='numeric') data = np.random.rand(4, size1, size2) with meas.run(write_in_background=bg_writing) as datasaver: datasaver.add_result( (str(x1), data[0, :, :]), (str(x2), data[1, :, :]), (str(y1), data[2, :, :]), (str(y2), data[3, :, :])) 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_datasaver_unsized_arrays(empty_temp_db, N): new_experiment('firstexp', sample_name='no sample') meas = Measurement() meas.register_custom_parameter(name='freqax', label='Frequency axis', unit='Hz') meas.register_custom_parameter(name='signal', label='qubit signal', unit='Majorana number', setpoints=('freqax', )) # note that np.array(some_number) is not the same as the number # its also not an array with a shape. Check here that we handle it # correctly with meas.run() as datasaver: freqax = np.linspace(1e6, 2e6, N) signal = np.random.randn(N) for i in range(N): myfreq = np.array(freqax[i]) mysignal = np.array(signal[i]) datasaver.add_result(('freqax', myfreq), ('signal', mysignal)) assert datasaver.points_written == N
def array_in_scalar_dataset_unrolled(experiment): """ This fixture yields a dataset where an array-valued parameter is registered as a 'numeric' type and has an additional single-valued setpoint. We expect data to be saved as individual scalars, with the scalar setpoint repeated. """ 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 linear1d(param_set, start, stop, num_points, delay, *param_meas, append=None, save=True, atstart=None, ateach=None, atend=None, wallcontrol=None, wallcontrol_slope=None, setback=False): """ """ _flush_buffers(*param_meas) # Set up a plotting window if append is None or not append: win = pyplot.PlotWindow() win.win_title = 'ID: ' win.resize(1000, 600) elif isinstance(append, pyplot.PlotWindow): # Append to the given window win = append elif isinstance(append, bool): # Append to the last trace if true win = pyplot.PlotWindow.getWindows()[-1] else: raise ValueError( "Unknown argument to append. Either give a plot window" " or true to append to the last plot") # Register setpoints meas = Measurement() meas.register_parameter(param_set) param_set.post_delay = delay set_points = np.linspace(start, stop, num_points) # Keep track of data and plots output = [] data = [] plots = [] # Run @start functions _run_functions(atstart) # Register each of the sweep parameters and set up a plot window for them for p, parameter in enumerate(param_meas): print(parameter, param_set) meas.register_parameter(parameter, setpoints=(param_set, )) output.append([parameter, None]) # Create plot window if append is not None and append: plot = win.items[0] else: plot = win.addPlot(title="%s (%s) v.<br>%s (%s)" % (param_set.full_name, param_set.label, parameter.full_name, parameter.label)) # Figure out if we have 1d or 2d data shape = getattr(parameter, 'shape', None) if shape is not None and shape: # If we have 2d data, we need to know its length shape = shape[0] set_points_y = parameter.setpoints[0] # Create data array data.append(np.ndarray((num_points, shape))) else: # Create data arrays data.append(np.full(num_points, np.nan)) set_points_y = None plotdata = plot.plot(setpoint_x=set_points, setpoint_y=set_points_y, pen=(255, 0, 0), name=parameter.name) # Update axes if set_points_y is not None: plot.update_axes(param_set, parameter, param_y_setpoint=True) plotdata.update_histogram_axis(parameter) else: plot.update_axes(param_set, parameter) plots.append(plotdata) if wallcontrol is not None: wallcontrol_start = wallcontrol.get() step = (stop - start) / num_points with meas.run() as datasaver: # Set write period to much longer... datasaver.write_period = 120 # Update plot titles win.win_title += "{} ".format(datasaver.run_id) for i in range(len(param_meas)): plots[p]._parent.plot_title += " (id: %d)" % datasaver.run_id # Then, run the actual sweep for i, set_point in enumerate(set_points): if wallcontrol is not None: wallcontrol.set(wallcontrol_start + i * step * wallcontrol_slope) param_set.set(set_point) _run_functions(ateach) for p, parameter in enumerate(param_meas): output[p][1] = parameter.get() shape = getattr(parameter, 'shape', None) if shape is not None and shape: data[p][i, :] = output[p][1] # Update 2D data if i == 0: data[p][1:] = (np.min(output[p][1]) + np.max(output[p][1])) / 2 else: data[p][i] = output[p][1] # Update 1D data # Update live plots plots[p].update(data[p]) # Save data datasaver.add_result((param_set, set_point), *output) if wallcontrol is not None: wallcontrol.set(wallcontrol_start) if setback: param_set.set(start) _run_functions(atend) if save: plot_tools.save_figure(win, datasaver.run_id) return (datasaver.run_id, win) # can use plot_by_id(dataid)
def linear2d(param_set1, start1, stop1, num_points1, delay1, param_set2, start2, stop2, num_points2, delay2, *param_meas, save=True): _flush_buffers(*param_meas) # Set up a plotting window win = pyplot.PlotWindow() win.win_title = 'ID: ' win.resize(800, 800) # Register setpoints meas = Measurement() # Step Axis meas.register_parameter(param_set1) param_set1.post_delay = delay1 set_points1 = np.linspace(start1, stop1, num_points1) # Sweep Axis meas.register_parameter(param_set2) param_set2.post_delay = delay2 set_points2 = np.linspace(start2, stop2, num_points2) # Keep track of data and plots output = [] data = np.ndarray((len(param_meas), num_points1, num_points2)) plots = [] for p, parameter in enumerate(param_meas): meas.register_parameter(parameter, setpoints=(param_set1, param_set2)) output.append([parameter, None]) # Add Plot item plot = win.addPlot(title="%s (%s) v.<br>%s (%s)" % (param_set1.full_name, param_set1.label, param_set2.full_name, param_set2.label)) plotdata = plot.plot(setpoint_x=set_points1, setpoint_y=set_points2) plot.update_axes(param_set1, param_set2) plotdata.update_histogram_axis(parameter) plots.append(plotdata) with meas.run() as datasaver: # Set write period to much longer... datasaver.write_period = 120 # Update plot titles win.win_title += "{} ".format(datasaver.run_id) for i in range(len(param_meas)): plots[i]._parent.plot_title += " (id: %d)" % datasaver.run_id plots[i].pause_update() for i, set_point1 in enumerate(set_points1): param_set2.set(start2) param_set1.set(set_point1) for j, set_point2 in enumerate(set_points2): param_set2.set(set_point2) for p, parameter in enumerate(param_meas): output[p][1] = parameter.get() fdata = data[p] fdata[i, j] = output[p][1] if i == 0: # Calculate z-range of data, and remove NaN's from first column # This sets zero point for rest of data z_range = (np.nanmin(fdata[i, :j + 1]), np.nanmax(fdata[i, :j + 1])) fdata[0, j + 1:] = (z_range[0] + z_range[1]) / 2 fdata[1:, :] = (z_range[0] + z_range[1]) / 2 # Update plot items, and update range every 10 points if (num_points1 * num_points2) < 1000 or (j % 20) == 0: plots[p].update(fdata, update_range=((j % 100) == 0)) # Save data datasaver.add_result((param_set1, set_point1), (param_set2, set_point2), *output) for i in range(len(param_meas)): fdata = data[i] plots[i].update(fdata, True) plots[i].resume_update() if save: plot_tools.save_figure(win, datasaver.run_id) return (datasaver.run_id, win)