def set_meas(dep, fast_indep, slow_indep=None, setup=setup, cleanup=cleanup):
"""
Regestration of the parameters and setting up before/after run procedure
args:
dep: InstParameter to be regestered as dependent var
fast_indep: InstParameter to be regestered as fast independent var
slow_indep: InstParameter to be regestered as second independent var (if any)
setup: Procedure to be done before run
cleanup: Procedure to be done after run
returns:
meas: Measurement() object
"""
meas = Measurement()
meas.register_parameter(
fast_indep) # register the fast independent parameter
if slow_indep is not None:
meas.register_parameter(
slow_indep) # register the first independent parameter
meas.register_parameter(dep, setpoints=(slow_indep, fast_indep))
else:
meas.register_parameter(dep, setpoints=(fast_indep, ))
meas.add_before_run(setup, args=())
meas.add_after_run(cleanup, args=())
meas.write_period = 2
return meas
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_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)
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 test_subscriptions(experiment, DAC, DMM):
def subscriber1(results, length, state):
"""
A dict of all results
"""
state[length] = results
def subscriber2(results, length, state):
"""
A list of all parameter values larger than 7
"""
for res in results:
state += [pres for pres in res if pres > 7]
meas = Measurement(exp=experiment)
meas.register_parameter(DAC.ch1)
meas.register_parameter(DMM.v1, setpoints=(DAC.ch1, ))
res_dict = {}
lt7s = []
meas.add_subscriber(subscriber1, state=res_dict)
assert len(meas.subscribers) == 1
meas.add_subscriber(subscriber2, state=lt7s)
assert len(meas.subscribers) == 2
meas.write_period = 0.2
expected_list = []
with meas.run() as datasaver:
assert len(datasaver._dataset.subscribers) == 2
assert res_dict == {}
assert lt7s == []
as_and_bs = list(zip(range(5), range(3, 8)))
for num in range(5):
(a, b) = as_and_bs[num]
expected_list += [c for c in (a, b) if c > 7]
sleep(1.2 * meas.write_period)
datasaver.add_result((DAC.ch1, a), (DMM.v1, b))
assert lt7s == expected_list
assert list(res_dict.keys()) == [n for n in range(1, num + 2)]
assert len(datasaver._dataset.subscribers) == 0
def _set_write_period(meas: Measurement,
write_period: Optional[float] = None) -> None:
if write_period is not None:
meas.write_period = write_period
def linear2d(param_set1,
start1,
stop1,
num_points1,
delay1,
param_set2,
start2,
stop2,
num_points2,
delay2,
*param_meas,
win=None,
append=False,
plot_params=None,
atstart=None,
ateachcol=None,
ateach=None,
atend=None,
setback=False,
write_period=120):
"""
Run a sweep of a single parameter, between start and stop, with a delay after settings
the point given by delay.
Args:
param_set1 (Parameter): The parameter to be stepped on the x-axis
start1 (Union[int, float]): Starting point of the x-axis parameter
stop1 (Union[int, float]): End point of the x-axis parameter
num_points1 (int): Number of points to take between start and stop (inclusive) on the x-axis
delay1 (Union[int, float]): The delay after setting the parameter on the x-axis
param_set2 (Parameter): The parameter to be swept on the y-axis
start2 (Union[int, float]): Starting point of the y-axis parameter
stop2 (Union[int, float]): End point of the y-axis parameter
num_points2 (int): Number of points to take between start and stop (inclusive) on the y-axis
delay2 (Union[int, float]): The delay after setting the parameter on the y-axis
*param_meas (Iterable[Parameter]): A list of the parameters to be measured at each of the
set points. These must be single valued for live plotting to work
win (Optional[PlotWindow]): The plot window to add plots to. If this value is None, the sweep
will not be live plotted.
append (bool): If this parameter is true, the trace will be appended to an existing window.
plot_params (Optional[Iterable[Parameter]]): A list of measured parameters to live plot. If no
value is given, then all parameters will be live-plotted
atstart (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run before the measurement is started. The functions will be run BEFORE the parameters
are inserted into the measurement, hence if some parameters require setup before they are run,
they can be inserted here.
ateachcol (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run after each column of data is complete, useful for example for doing more advanced
wall control. These functions are run AFTER the delay.
ateach (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run after each time the sweep parameter is set. These functions will be run AFTER
the delay, and so is suitable if an instrument requires a call to capture a trace before
the parameter can be read.
atend (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run at the end of a trace. This is run AFTER the data is saved into the database,
and after parameters are set back to their starting points (if setback is True), and
can therefore be used to read the data that was taken and potentially do some post analysis.
setback (Optional[bool]): If this is True, the setpoint parameter is returned to its starting
value at the end of the sweep.
write_period (Optional[int]): The time inbetween which data is written to the database.
Irrespective of what this is set to, data will be saved when the week finishes, and will attempt
to save in the case the sweep is interrupted.
Returns:
(id, win): ID is the trace id of the saved wave, win is a handle to the plot window that was created
for the purposes of liveplotting.
"""
_flush_buffers(*param_meas)
# 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
if plot_params is None:
plot_params = param_meas
output = []
plots = {}
# Run @start functions
_run_functions(atstart)
# Register each parameter
for p, parameter in enumerate(param_meas):
meas.register_parameter(parameter, setpoints=(param_set1, param_set2))
output.append([parameter, None])
# Add Plot item
if win is not None and parameter in plot_params:
if append:
plotitem = win.items[0]
plotdata = plotitem.plot(setpoint_x=set_points1,
setpoint_y=set_points2)
else:
plotitem = win.addPlot(
name=parameter.full_name,
title="%s (%s) v.<br>%s (%s)" %
(param_set1.full_name, param_set1.label,
param_set2.full_name, param_set2.label))
plotdata = plotitem.plot(setpoint_x=set_points1,
setpoint_y=set_points2)
plotitem.update_axes(param_set1, param_set2)
plotdata.update_histogram_axis(parameter)
plots[parameter] = LivePlotDataItem(
plotitem, plotdata, np.ndarray((num_points1, num_points2)))
meas.write_period = write_period
pbar = None
try:
with meas.run() as datasaver:
# Update plot titles
win.run_id = datasaver.run_id
win.win_title += "{} ".format(datasaver.run_id)
for plotitem in plots.values():
plotitem.plot.plot_title += " (id: %d)" % datasaver.run_id
pbar = tqdm(total=num_points1, unit="col", position=0, leave=True)
for i, set_point1 in enumerate(set_points1):
param_set2.set(start2)
param_set1.set(set_point1)
_run_functions(ateachcol,
param_vals=(Setpoint(param_set1, i,
set_point1), ))
for j, set_point2 in enumerate(set_points2):
param_set2.set(set_point2)
_run_functions(
ateach,
param_vals=(Setpoint(param_set1, i, set_point1),
Setpoint(param_set2, j, set_point2)))
for p, parameter in enumerate(param_meas):
output[p][1] = parameter.get()
if win is not None and parameter in plots:
fdata = plots[parameter].data
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[parameter].plotdata.update(fdata, True)
# Save data
datasaver.add_result((param_set1, set_point1),
(param_set2, set_point2), *output)
pbar.update(1)
# At the end, do one last update to make sure that all data is displayed.
if win is not None:
for pd in plots.values():
pd.plotdata.update(pd.data, True)
finally:
# Set paramters back to start
if setback:
param_set1.set(start1)
param_set2.set(start2)
# Close progress bar
if pbar is not None:
pbar.close()
_run_functions(atend)
return datasaver.run_id
def linear1d(param_set,
start,
stop,
num_points,
delay,
*param_meas,
win=None,
append=False,
plot_params=None,
atstart=None,
ateach=None,
atend=None,
setback=False,
write_period=120):
"""
Run a sweep of a single parameter, between start and stop, with a delay after settings
the point given by delay.
Args:
param_set (Parameter): The parameter to be swept
start (Union[int, float]): Starting point of the parameter
stop (Union[int, float]): End point of the parameter
num_points (int): Number of points to take between start and stop (inclusive)
delay (Union[int, float]): The delay after setting the parameter
*param_meas (Iterable[Parameter]): A list of the parameters to be measured at each of the
set points. If any of the parameters given are ArrayParameters then a 2D sweep will be
taken on that parameter, using the setpoints given in that ArrayParamter.
Note: At the current time, there is an assumption that the setpoints do NOT change during
a measurement, and that points are uniformly distributed for the purposes of plotting.
If the points are not uniformly distributed, data is correctly saved, however the live
plot will be distorted.
win (Optional[PlotWindow]): The plot window to add plots to. If this value is None, the sweep
will not be live plotted.
append (bool): If this parameter is true, the trace will be appended to an existing window.
plot_params (Optional[Iterable[Parameter]]): A list of measured parameters to live plot. If no
value is given, then all parameters will be live-plotted
atstart (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run before the measurement is started. The functions will be run BEFORE the parameters
are inserted into the measurement, hence if some parameters require setup before they are run,
they can be inserted here.
ateach (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run after each time the sweep parameter is set. These functions will be run AFTER
the delay, and so is suitable if an instrument requires a call to capture a trace before
the parameter can be read.
atend (Optional[Union[Callable,Iterable[Callable]]]): A function or list of functions
to be run at the end of a trace. This is run AFTER the data is saved into the database,
and after parameters are set back to their starting points (if setback is True), and
can therefore be used to read the data that was taken and potentially do some post analysis.
setback (Optional[bool]): If this is True, the setpoint parameter is returned to its starting
value at the end of the sweep.
write_period (Optional[int]): The time inbetween which data is written to the database.
Irrespective of what this is set to, data will be saved when the week finishes, and will attempt
to save in the case the sweep is interrupted.
Returns:
(id, win): ID is the trace id of the saved wave, win is a handle to the plot window that was created
for the purposes of liveplotting.
"""
_flush_buffers(*param_meas)
# 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
if plot_params is None:
plot_params = param_meas
output = []
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):
meas.register_parameter(parameter, setpoints=(param_set, ))
output.append([parameter, None])
if win is not None and parameter in plot_params:
# Create plot window
if append:
plotitem = win.items[0]
else:
plotitem = win.addPlot(name=parameter.full_name,
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 != tuple():
set_points_y = parameter.setpoints[0]
data = np.ndarray((num_points, parameter.shape[0]))
else:
set_points_y = None
data = np.full(num_points, np.nan)
# Add data into the plot window
plotdata = plotitem.plot(setpoint_x=set_points,
setpoint_y=set_points_y,
pen=(255, 0, 0),
name=parameter.name)
plots[parameter] = LivePlotDataItem(plotitem, plotdata, data)
# Update axes
if set_points_y is not None:
plotitem.update_axes(param_set,
parameter,
param_y_setpoint=True)
plotdata.update_histogram_axis(parameter)
else:
plotitem.update_axes(param_set, parameter)
# Run the sweep
meas.write_period = write_period
pbar = None
try:
with meas.run() as datasaver:
if win is not None:
# Update plot titles to include the ID
win.run_id = datasaver.run_id
win.win_title += "{} ".format(datasaver.run_id)
for plotitem in plots.values():
plotitem.plot.plot_title += " (id: %d)" % datasaver.run_id
# Then, run the actual sweep
pbar = tqdm(total=num_points, unit="pt", position=0, leave=True)
for i, set_point in enumerate(set_points):
param_set.set(set_point)
_run_functions(ateach,
param_vals=(Setpoint(param_set, i,
set_point), ))
# Read out each parameter
for p, parameter in enumerate(param_meas):
output[p][1] = parameter.get()
shape = getattr(parameter, 'shape', None)
if win is not None and parameter in plots:
if shape is not None and shape != tuple():
plots[parameter].data[i, :] = output[p][
1] # Update 2D data
# For a 2D trace, figure out the value for data not yet set if this is the
# first column
if i == 0:
plots[parameter].data[1:] = (np.min(
output[p][1]) + np.max(output[p][1])) / 2
# Update live plots
plots[parameter].plotdata.update(
plots[parameter].data)
else:
plots[parameter].data[i] = output[p][
1] # Update 1D data
plots[parameter].plotdata.setData(
set_points[:i], plots[parameter].data[:i])
# Save data
datasaver.add_result((param_set, set_point), *output)
pbar.update(1)
finally:
# Set back to start at the end of the measurement
if setback:
param_set.set(start)
# Close the progress bar
if pbar is not None:
pbar.close()
_run_functions(atend) # Run functions at the end
# Return the dataid
return datasaver.run_id # can use plot_by_id(dataid)
def test_subscriptions(experiment, DAC, DMM):
"""
Test that subscribers are called at the moment that data is flushed to database
Note that for the purpose of this test, flush_data_to_database method is called explicitly instead of waiting for
the data to be flushed automatically after the write_period passes after a add_result call.
Args:
experiment (qcodes.dataset.experiment_container.Experiment) : qcodes experiment object
DAC (qcodes.instrument.base.Instrument) : dummy instrument object
DMM (qcodes.instrument.base.Instrument) : another dummy instrument object
"""
def subscriber1(results, length, state):
"""
A dict of all results
"""
state[length] = results
def subscriber2(results, length, state):
"""
A list of all parameter values larger than 7
"""
for res in results:
state += [pres for pres in res if pres > 7]
meas = Measurement(exp=experiment)
meas.register_parameter(DAC.ch1)
meas.register_parameter(DMM.v1, setpoints=(DAC.ch1, ))
res_dict = {}
lt7s = []
meas.add_subscriber(subscriber1, state=res_dict)
assert len(meas.subscribers) == 1
meas.add_subscriber(subscriber2, state=lt7s)
assert len(meas.subscribers) == 2
meas.write_period = 0.2
expected_list = []
with meas.run() as datasaver:
assert len(datasaver._dataset.subscribers) == 2
assert res_dict == {}
assert lt7s == []
as_and_bs = list(zip(range(5), range(3, 8)))
for num in range(5):
(a, b) = as_and_bs[num]
expected_list += [c for c in (a, b) if c > 7]
datasaver.add_result((DAC.ch1, a), (DMM.v1, b))
datasaver.flush_data_to_database()
assert lt7s == expected_list
assert list(res_dict.keys()) == [n for n in range(1, num + 2)]
assert len(datasaver._dataset.subscribers) == 0
def test_subscriptions(experiment, DAC, DMM):
"""
Test that subscribers are called at the moment the data is flushed to database
Note that for the purpose of this test, flush_data_to_database method is
called explicitly instead of waiting for the data to be flushed
automatically after the write_period passes after a add_result call.
"""
def collect_all_results(results, length, state):
"""
Updates the *state* to contain all the *results* acquired
during the experiment run
"""
# Due to the fact that by default subscribers only hold 1 data value
# in their internal queue, this assignment should work (i.e. not
# overwrite values in the "state" object) assuming that at the start
# of the experiment both the dataset and the *state* objects have
# the same length.
state[length] = results
def collect_values_larger_than_7(results, length, state):
"""
Appends to the *state* only the values from *results*
that are larger than 7
"""
for result_tuple in results:
state += [value for value in result_tuple if value > 7]
meas = Measurement(exp=experiment)
meas.register_parameter(DAC.ch1)
meas.register_parameter(DMM.v1, setpoints=(DAC.ch1, ))
# key is the number of the result tuple,
# value is the result tuple itself
all_results_dict = {}
values_larger_than_7 = []
meas.add_subscriber(collect_all_results, state=all_results_dict)
assert len(meas.subscribers) == 1
meas.add_subscriber(collect_values_larger_than_7,
state=values_larger_than_7)
assert len(meas.subscribers) == 2
meas.write_period = 0.2
with meas.run() as datasaver:
# Assert that the measurement, runner, and datasaver
# have added subscribers to the dataset
assert len(datasaver._dataset.subscribers) == 2
assert all_results_dict == {}
assert values_larger_than_7 == []
dac_vals_and_dmm_vals = list(zip(range(5), range(3, 8)))
values_larger_than_7__expected = []
for num in range(5):
(dac_val, dmm_val) = dac_vals_and_dmm_vals[num]
values_larger_than_7__expected += \
[val for val in (dac_val, dmm_val) if val > 7]
datasaver.add_result((DAC.ch1, dac_val), (DMM.v1, dmm_val))
# Ensure that data is flushed to the database despite the write
# period, so that the database triggers are executed, which in turn
# add data to the queues within the subscribers
datasaver.flush_data_to_database()
# In order to make this test deterministic, we need to ensure that
# just enough time has passed between the moment the data is flushed
# to database and the "state" object (that is passed to subscriber
# constructor) has been updated by the corresponding subscriber's
# callback function. At the moment, there is no robust way to ensure
# this. The reason is that the subscribers have internal queue which
# is populated via a trigger call from the SQL database, hence from
# this "main" thread it is difficult to say whether the queue is
# empty because the subscriber callbacks have already been executed
# or because the triggers of the SQL database has not been executed
# yet.
#
# In order to overcome this problem, a special decorator is used
# to wrap the assertions. This is going to ensure that some time
# is given to the Subscriber threads to finish exhausting the queue.
@retry_until_does_not_throw(
exception_class_to_expect=AssertionError, delay=0.5, tries=10)
def assert_states_updated_from_callbacks():
assert values_larger_than_7 == values_larger_than_7__expected
assert list(all_results_dict.keys()) == \
[result_index for result_index in range(1, num + 1 + 1)]
assert_states_updated_from_callbacks()
# Ensure that after exiting the "run()" context,
# all subscribers get unsubscribed from the dataset
assert len(datasaver._dataset.subscribers) == 0
# Ensure that the triggers for each subscriber
# have been removed from the database
get_triggers_sql = "SELECT * FROM sqlite_master WHERE TYPE = 'trigger';"
triggers = atomic_transaction(datasaver._dataset.conn,
get_triggers_sql).fetchall()
assert len(triggers) == 0
def do2d(param_set1: _BaseParameter,
start1: number,
stop1: number,
num_points1: int,
delay1: number,
param_set2: _BaseParameter,
start2: number,
stop2: number,
num_points2: int,
delay2: number,
*param_meas: Union[_BaseParameter, Callable[[], None]],
set_before_sweep: Optional[bool] = False,
enter_actions: Sequence[Callable[[], None]] = (),
exit_actions: Sequence[Callable[[], None]] = (),
before_inner_actions: Sequence[Callable[[], None]] = (),
after_inner_actions: Sequence[Callable[[], None]] = (),
write_period: Optional[float] = None,
flush_columns: bool = False,
do_plot: bool = True,
conDuct: Instrument = None) -> AxesTupleListWithRunId:
"""
adapted for logging settings by felix 17.04.2020
-added argument do2buf
-added _export_settings functionality
adapted for live plotting of conductance by felix 17.04.2020
-added argument conDuct
-conDuct is a virtual parameter who has to be called as an optional argument in do1D.
conDuct has a function calcG() which allows to calculate the division of two given
parameters or one parameter and a float number. See init file for more info.
Perform a 1D scan of ``param_set1`` from ``start1`` to ``stop1`` in
``num_points1`` and ``param_set2`` from ``start2`` to ``stop2`` in
``num_points2`` measuring param_meas at each step.
Args:
param_set1: The QCoDeS parameter to sweep over in the outer loop
start1: Starting point of sweep in outer loop
stop1: End point of sweep in the outer loop
num_points1: Number of points to measure in the outer loop
delay1: Delay after setting parameter in the outer loop
param_set2: The QCoDeS parameter to sweep over in the inner loop
start2: Starting point of sweep in inner loop
stop2: End point of sweep in the inner loop
num_points2: Number of points to measure in the inner loop
delay2: Delay after setting paramter before measurement is performed
*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.
set_before_sweep: if True the outer parameter is set to its first value
before the inner parameter is swept to its next value.
enter_actions: A list of functions taking no arguments that will be
called before the measurements start
exit_actions: A list of functions taking no arguments that will be
called after the measurements ends
before_inner_actions: Actions executed before each run of the inner loop
after_inner_actions: Actions executed after each run of the inner loop
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()
if write_period:
meas.write_period = write_period
meas.register_parameter(param_set1)
param_set1.post_delay = delay1
meas.register_parameter(param_set2)
param_set2.post_delay = delay2
interrupted = False
for action in enter_actions:
# this omits the possibility of passing
# argument to enter and exit actions.
# Do we want that?
meas.add_before_run(action, ())
for action in exit_actions:
meas.add_after_run(action, ())
for parameter in param_meas:
if isinstance(parameter, _BaseParameter):
meas.register_parameter(parameter,
setpoints=(param_set1, param_set2))
if conDuct != None:
meas.register_parameter(conDuct.G,
setpoints=(param_set1, param_set2))
try:
with meas.run() as datasaver:
start_time = time.perf_counter()
os.makedirs(datapath + '{}'.format(datasaver.run_id))
for set_point1 in np.linspace(start1, stop1, num_points1):
if set_before_sweep:
param_set2.set(start2)
param_set1.set(set_point1)
for action in before_inner_actions:
action()
for set_point2 in np.linspace(start2, stop2, num_points2):
# skip first inner set point if `set_before_sweep`
if set_point2 == start2 and set_before_sweep:
pass
else:
param_set2.set(set_point2)
output = []
for parameter in param_meas:
if isinstance(parameter, _BaseParameter):
output.append((parameter, parameter.get()))
elif callable(parameter):
parameter()
if conDuct != None:
output.append((conDuct.G, conDuct.calcG(output)))
datasaver.add_result((param_set1, set_point1),
(param_set2, set_point2), *output)
for action in after_inner_actions:
action()
if flush_columns:
datasaver.flush_data_to_database()
stop_time = time.perf_counter()
except KeyboardInterrupt:
interrupted = True
dataid = datasaver.run_id
if interrupted:
inst = list(meas.parameters.values())
exportpath = datapath + '{}'.format(
datasaver.run_id) + '/{}_set_{}_set.dat'.format(
inst[0].name, inst[1].name)
exportsnapshot = datapath + '{}'.format(
datasaver.run_id) + '/snapshot.txt'
#export_by_id(dataid,exportpath)
export_by_id_pd(dataid, exportpath)
export_snapshot_by_id(dataid, exportsnapshot)
#added by felix 05.03.2020
_export_settings(datasaver.run_id, inst)
stop_time = time.perf_counter()
print("Acquisition took: %s seconds " % (stop_time - start_time))
raise KeyboardInterrupt
inst = list(meas.parameters.values())
exportpath = datapath + '{}'.format(
datasaver.run_id) + '/{}_set_{}_set.dat'.format(
inst[0].name, inst[1].name)
exportsnapshot = datapath + '{}'.format(datasaver.run_id) + '/snapshot.txt'
#export_by_id(dataid,exportpath)
export_by_id_pd(dataid, exportpath)
export_snapshot_by_id(dataid, exportsnapshot)
# _export_settings(datasaver.run_id,inst)
if do_plot is True:
ax, cbs = _save_image(datasaver, inst)
else:
ax = None,
cbs = None
print("Acquisition took: %s seconds " % (stop_time - start_time))
return dataid, ax, cbs
