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