Exemplo n.º 1
0
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
Exemplo n.º 2
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