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_enter_and_exit_actions(experiment, DAC, words):
# we use a list to check that the functions executed
# in the correct order
def action(lst, word):
lst.append(word)
meas = Measurement()
meas.register_parameter(DAC.ch1)
testlist = []
splitpoint = round(len(words) / 2)
for n in range(splitpoint):
meas.add_before_run(action, (testlist, words[n]))
for m in range(splitpoint, len(words)):
meas.add_after_run(action, (testlist, words[m]))
assert len(meas.enteractions) == splitpoint
assert len(meas.exitactions) == len(words) - splitpoint
with meas.run() as _:
assert testlist == words[:splitpoint]
assert testlist == words
meas = Measurement()
with pytest.raises(ValueError):
meas.add_before_run(action, 'no list!')
with pytest.raises(ValueError):
meas.add_after_run(action, testlist)
def _register_actions(meas: Measurement, enter_actions: ActionsT,
exit_actions: ActionsT) -> None:
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, ())
def inject_to_target(exp, station, fn_switch, events, target):
"""
open loop sweep of vref
"""
# Set the switch state to 'open'
if not callable(fn_switch):
raise ValueError("Expecting Switch Function")
fn_switch("open")
voltages = {
"vdd": 0,
"vfeedback": 0,
"vdrain": 0,
"vbias": 0,
"vref": 0,
"vtun": 2,
"vbus": 2
}
deps = [
station.b2962.IDRAIN, station.dmm.VOUT, station.n6705b.VBUS,
station.n6705b.VFEEDBACK, station.n6705b.VREF, station.n6705b.VTUN,
station.b2962.VDD, station.b2962.VDRAIN, station.yoko.VBIAS
]
meas = Measurement(exp=exp, station=station)
meas.register_custom_parameter("time", label="Time", unit="S")
meas.register_custom_parameter("injection_target",
label="Injection Target",
unit="A")
meas.add_before_run(lambda: setup(station, voltages), ())
meas.add_after_run(lambda: all_disable(station), ())
for p in deps:
meas.register_parameter(p, setpoints=("time", ))
with meas.run() as datasaver:
time.sleep(1)
start = time.time()
events.fn_before()
while (station.b2962.IDRAIN() > target):
save_list = []
save_list.append(["time", time.time() - start])
save_list.append(["injection_target", target])
for p in deps:
save_list.append([p, p.get()])
datasaver.add_result(*save_list)
time.sleep(events.step)
runid = datasaver.run_id
return runid
def tunnel_to_target(exp, station, fn_switch, voltages, vtun, target):
"""
open loop sweep of vref
"""
# Set the switch state to 'open'
if not callable(fn_switch):
raise ValueError("Expecting Switch Function")
fn_switch("close")
deps = [
station.dmm.VOUT, station.n6705b.VBUS, station.n6705b.VFEEDBACK,
station.n6705b.VREF, station.n6705b.VTUN, station.b2962.VDD,
station.b2962.VDRAIN, station.yoko.VBIAS
]
meas = Measurement(exp=exp, station=station)
meas.register_custom_parameter("time", label="Time", unit="S")
meas.register_custom_parameter("tunnel_target",
label="Tunnel Target",
unit="V")
meas.add_before_run(lambda: setup(station, voltages), ())
meas.add_after_run(lambda: all_disable(station), ())
for p in deps:
meas.register_parameter(p, setpoints=("time", ))
voltages['vtun'] = vtun
with meas.run() as datasaver:
time.sleep(1)
start = time.time()
print(station.dmm.VOUT())
while (station.dmm.VOUT() > target):
save_list = []
save_list.append(["time", time.time() - start])
save_list.append(["tunnel_target", target])
for p in deps:
save_list.append([p, p.get()])
datasaver.add_result(*save_list)
time.sleep(0.1)
runid = datasaver.run_id
return runid
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 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 do1d(param_set: _BaseParameter, start: number, stop: number,
num_points: int, delay: number,
*param_meas: Union[_BaseParameter, Callable[[], None]],
enter_actions: Sequence[Callable[[], None]] = (),
exit_actions: Sequence[Callable[[], None]] = (),
do_plot: bool = True,
do2dbuf: str = '',
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_set`` from ``start`` to ``stop`` in
``num_points`` measuring param_meas at each step. In case param_meas is
an ArrayParameter this is effectively a 2d scan.
Args:
param_set: The QCoDeS parameter to sweep over
start: Starting point of sweep
stop: End point of sweep
num_points: Number of points in sweep
delay: 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.
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
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()
meas.register_parameter(
param_set) # register the first independent parameter
output = []
param_set.post_delay = delay
interrupted = False
for action in enter_actions:
# this omits the posibility 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, ())
# do1D enforces a simple relationship between measured parameters
# and set parameters. For anything more complicated this should be
# reimplemented from scratch
for parameter in param_meas:
if isinstance(parameter, _BaseParameter):
meas.register_parameter(parameter, setpoints=(param_set, ))
output.append([parameter, None])
if conDuct != None:
meas.register_parameter(conDuct.G, setpoints=(param_set, ))
output.append([conDuct.G, None])
try:
with meas.run() as datasaver:
start_time = time.perf_counter()
os.makedirs(datapath + '{}'.format(datasaver.run_id))
for set_point in np.linspace(start, stop, num_points):
param_set.set(set_point)
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_set, set_point), *output)
except KeyboardInterrupt:
interrupted = True
stop_time = time.perf_counter()
dataid = datasaver.run_id # convenient to have for plotting
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)
_export_settings(datasaver.run_id, inst, do2dbuf)
stop_time = time.perf_counter()
print("Acquisition took: %s seconds " % (stop_time - start_time))
raise KeyboardInterrupt
print("Acquisition took: %s seconds " % (stop_time - start_time))
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, do2dbuf)
if do_plot is True:
ax, cbs = _save_image(datasaver, inst)
else:
ax = None,
cbs = None
return dataid, ax, cbs
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
def do1d(param_set: _BaseParameter, start: number, stop: number,
num_points: int, delay: number,
*param_meas: Union[_BaseParameter, Callable[[], None]],
enter_actions: Sequence[Callable[[], None]] = (),
exit_actions: Sequence[Callable[[], None]] = (),
do_plot: bool = True) \
-> AxesTupleListWithRunId:
"""
Perform a 1D scan of ``param_set`` from ``start`` to ``stop`` in
``num_points`` measuring param_meas at each step. In case param_meas is
an ArrayParameter this is effectively a 2d scan.
Args:
param_set: The QCoDeS parameter to sweep over
start: Starting point of sweep
stop: End point of sweep
num_points: Number of points in sweep
delay: 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.
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
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()
meas.register_parameter(
param_set) # register the first independent parameter
output = []
param_set.post_delay = delay
interrupted = False
for action in enter_actions:
# this omits the posibility 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, ())
# do1D enforces a simple relationship between measured parameters
# and set parameters. For anything more complicated this should be
# reimplemented from scratch
for parameter in param_meas:
if isinstance(parameter, _BaseParameter):
meas.register_parameter(parameter, setpoints=(param_set, ))
output.append([parameter, None])
try:
with meas.run() as datasaver:
for set_point in np.linspace(start, stop, num_points):
param_set.set(set_point)
output = []
for parameter in param_meas:
if isinstance(parameter, _BaseParameter):
output.append((parameter, parameter.get()))
elif callable(parameter):
parameter()
datasaver.add_result((param_set, set_point), *output)
except KeyboardInterrupt:
interrupted = True
dataid = datasaver.run_id # convenient to have for plotting
if do_plot is True:
ax, cbs = _save_image(datasaver)
else:
ax = None,
cbs = None
if interrupted:
raise KeyboardInterrupt
return dataid, ax, cbs
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]] = (),
do_plot: bool = True) -> AxesTupleListWithRunId:
"""
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()
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))
try:
with meas.run() as datasaver:
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()
datasaver.add_result((param_set1, set_point1),
(param_set2, set_point2), *output)
for action in after_inner_actions:
action()
except KeyboardInterrupt:
interrupted = True
dataid = datasaver.run_id
if do_plot is True:
ax, cbs = _save_image(datasaver)
else:
ax = None,
cbs = None
if interrupted:
raise KeyboardInterrupt
return dataid, ax, cbs
