From 95ea1763723040a43db65bec65b26a32ed3c7174 Mon Sep 17 00:00:00 2001
From: Stephan Philips <s.g.j.philips@tudelft.nl>
Date: Sat, 6 Jun 2020 22:46:28 +0200
Subject: [PATCH] added generic scan functions in qcodes new dataset format
---
.../__pycache__/DEMOD_tests.cpython-36.pyc | Bin 3209 -> 0 bytes
.../__pycache__/__init__.cpython-36.pyc | Bin 161 -> 0 bytes
.../__pycache__/mod_test.cpython-36.pyc | Bin 12204 -> 0 bytes
.../__pycache__/__init__.cpython-37.opt-2.pyc | Bin 145 -> 0 bytes
.../__pycache__/__init__.cpython-37.pyc | Bin 138 -> 0 bytes
.../pulse_lib_sweep.cpython-37.opt-2.pyc | Bin 7787 -> 0 bytes
.../pulse_lib_sweep.cpython-37.pyc | Bin 8818 -> 0 bytes
core_tools/sweeps/progressbar.py | 25 +++
core_tools/sweeps/pulselib2qcodes.py | 180 ++++++++++++++++++
core_tools/sweeps/sweep_utility.py | 103 ++++++++++
core_tools/sweeps/sweeps.py | 179 +++++++++++++++++
.../Modulated_scans/DEMOD_tests.py | 0
.../Modulated_scans/__init__.py | 0
.../Modulated_scans/mod_test.py | 0
core_tools/sweeps/sweeps_old/__init__.py | 0
.../{ => sweeps_old}/exp_readout_runner.py | 0
.../{ => sweeps_old}/pulse_lib_sweep.py | 0
17 files changed, 487 insertions(+)
delete mode 100644 core_tools/sweeps/Modulated_scans/__pycache__/DEMOD_tests.cpython-36.pyc
delete mode 100644 core_tools/sweeps/Modulated_scans/__pycache__/__init__.cpython-36.pyc
delete mode 100644 core_tools/sweeps/Modulated_scans/__pycache__/mod_test.cpython-36.pyc
delete mode 100644 core_tools/sweeps/__pycache__/__init__.cpython-37.opt-2.pyc
delete mode 100644 core_tools/sweeps/__pycache__/__init__.cpython-37.pyc
delete mode 100644 core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.opt-2.pyc
delete mode 100644 core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.pyc
create mode 100644 core_tools/sweeps/progressbar.py
create mode 100644 core_tools/sweeps/pulselib2qcodes.py
create mode 100644 core_tools/sweeps/sweep_utility.py
create mode 100644 core_tools/sweeps/sweeps.py
rename core_tools/sweeps/{ => sweeps_old}/Modulated_scans/DEMOD_tests.py (100%)
rename core_tools/sweeps/{ => sweeps_old}/Modulated_scans/__init__.py (100%)
rename core_tools/sweeps/{ => sweeps_old}/Modulated_scans/mod_test.py (100%)
create mode 100644 core_tools/sweeps/sweeps_old/__init__.py
rename core_tools/sweeps/{ => sweeps_old}/exp_readout_runner.py (100%)
rename core_tools/sweeps/{ => sweeps_old}/pulse_lib_sweep.py (100%)
diff --git a/core_tools/sweeps/Modulated_scans/__pycache__/DEMOD_tests.cpython-36.pyc b/core_tools/sweeps/Modulated_scans/__pycache__/DEMOD_tests.cpython-36.pyc
deleted file mode 100644
index 90eda691eadb4195dd78ad233e84c973190e639a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 3209
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
G$NC==mN)4D
diff --git a/core_tools/sweeps/Modulated_scans/__pycache__/__init__.cpython-36.pyc b/core_tools/sweeps/Modulated_scans/__pycache__/__init__.cpython-36.pyc
deleted file mode 100644
index 831f8c239cfe43ec222fe837d223d4138741ad99..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 161
zcmXr!<>e~VJ{rpa1dl-k3@`#24nSPY0whuxf*CX!{Z=v*frJsnFTZ4~m@=dI<ouM>
znBs!WJl%q#{H)aElH!=s;?$zznBtPuf{etxm@uRG;{3Fd^2DOl7~lMq(wxMS)Rg$*
i<ixz<nE3e2yv&mLc)fzkTO2mIAlXzqkUhmf%m4sdBP(qH
diff --git a/core_tools/sweeps/Modulated_scans/__pycache__/mod_test.cpython-36.pyc b/core_tools/sweeps/Modulated_scans/__pycache__/mod_test.cpython-36.pyc
deleted file mode 100644
index 5d0692147c08b2735e9306bc7f9fb7c78204c976..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 12204
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
XwUk4-Q8P)dT6ju&)hy`8A(Q_PsKW8I
diff --git a/core_tools/sweeps/__pycache__/__init__.cpython-37.opt-2.pyc b/core_tools/sweeps/__pycache__/__init__.cpython-37.opt-2.pyc
deleted file mode 100644
index 650a11821c64ae38743818bdb25ae9b01d2f65f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 145
zcmZ?b<>g`kf?vv8<3RLd5CH>>K!yVl7qb9~6oz01O-8?!3`HPe1o6u%*(#<YCnY{P
zKP5FLCABOyC%+&!HLnCBkepwX8efv1pHm!DT%MX*P#hB<pP83g5+AQuP<e~PCO1E&
OG$+*#WaeieW&i+L^CZjw
diff --git a/core_tools/sweeps/__pycache__/__init__.cpython-37.pyc b/core_tools/sweeps/__pycache__/__init__.cpython-37.pyc
deleted file mode 100644
index 29eb9bf6d3c33b76b1150636201cf6da20d80b84..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 138
zcmZ?b<>g`kf<4xU;z0Cc5CH>>K!yVl7qb9~6oz01O-8?!3`HPe1o6u_*(#>YC_Xtq
zB{e2FzbG}nBtJi=7@1jIo|;-v91|a(nU`4-AFo$Xd5gm)H$SB`C)EyQ*k>SS001$5
BA*cWV
diff --git a/core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.opt-2.pyc b/core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.opt-2.pyc
deleted file mode 100644
index 5a9babac6b1d37f0cbeb18195eff2ec2fe9fb6de..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 7787
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
diff --git a/core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.pyc b/core_tools/sweeps/__pycache__/pulse_lib_sweep.cpython-37.pyc
deleted file mode 100644
index f93f2884ba64901205a20bd2845f59363058b6e0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 8818
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
V9{}es%$MdD<`?G|5dk@6@e2q^d=CHs
diff --git a/core_tools/sweeps/progressbar.py b/core_tools/sweeps/progressbar.py
new file mode 100644
index 00000000..47b13fd9
--- /dev/null
+++ b/core_tools/sweeps/progressbar.py
@@ -0,0 +1,25 @@
+import tqdm
+
+class progress_bar():
+ def __init__(self, n_tot):
+ self.bar = tqdm.tqdm(total = n_tot, unit='points', ncols=80)
+ self.n = 0
+
+ def __add__(self, n):
+ self.bar.update(n)
+ self.n += n
+ return self
+
+ def close(self):
+ self.bar.close()
+
+if __name__ == '__main__':
+ import time
+
+ p = progress_bar(50)
+
+ for i in range(50):
+ time.sleep(0.01)
+ p += 1
+
+ p.close()
\ No newline at end of file
diff --git a/core_tools/sweeps/pulselib2qcodes.py b/core_tools/sweeps/pulselib2qcodes.py
new file mode 100644
index 00000000..6fabf80a
--- /dev/null
+++ b/core_tools/sweeps/pulselib2qcodes.py
@@ -0,0 +1,180 @@
+from core_tools.sweeps.sweep_utility import sweep_info
+from qcodes import Parameter
+
+class PulseLibParameter(Parameter):
+ setpoints = None
+ flat_index = 0
+
+ def add_setpoints(self, setpoints, sequencer, lowest_level):
+ self.setpoints = setpoints
+ self.sequencer = sequencer
+ self.lowest_level = lowest_level
+
+ def get_raw(self):
+ current_val = self.setpoints[self.flat_index%len(self.setpoints)]
+
+ self.flat_index += 1
+ if self.flat_index > np.prod(self.sequencer.shape):
+ self.flat_index = 0
+
+ return current_val
+
+ def set_raw(self, value):
+ if self.lowest_level:
+ if self.flat_index == 0:
+ self.sequencer.upload(np.unravel_index(flat_index, self.sequencer.shape))
+
+ index = np.unravel_index(flat_index, self.shape)
+ self.sequencer.play(index)
+
+ if flat_index < np.prod(self.shape) - 1:
+ self.sequencer.upload(np.unravel_index(flat_index+1, self.shape))
+
+ self.sequencer.uploader.wait_until_AWG_idle()
+
+ '''
+ @ sander, how can we make sure that a unused upload is removed when the garbage collector collects this?
+ (e.g. when a set is performed to reset parameters -- normally this does not happen, but user might accidentatly do this.)
+ '''
+
+def pulselib_2_qcodes(awg_sequence):
+ '''
+ convert pulse sequencer object in qcodes parameters that are usable in sweeps.
+
+ Args:
+ awg_sequence (pulselib.sequencer.sequencer) : sequence object
+
+ Returns:
+ set_param (list<PulseLibParameter>) : set paramters for the pulselib to be used in the sweep
+ '''
+ set_param = list()
+ for i in range(len(awg_sequence.shape)):
+ param = PulseLibParameter(name = awg_sequence.labels[i].replace(" ", "_"), label=awg_sequence.labels[i], unit= awg_sequence.units[i])
+ param.add_setpoints(awg_sequence.setpoints[i], awg_sequence, False)
+ set_param.append(sweep_info(param, n_points = len(awg_sequence.setpoints[i])))
+
+ set_param[0].param.lowest_level=True
+
+ return set_param[::-1]
+
+
+
+if __name__ == '__main__':
+
+ from qcodes import Parameter, MultiParameter, new_experiment
+ import numpy as np
+ import time
+ new_experiment("name", "testing")
+
+ class test_AWG_sequence0D(object):
+ """docstring for test_AWG_sequence"""
+ def __init__(self):
+ super(test_AWG_sequence0D, self).__init__()
+ self.shape = (1, )
+ self.uploader = uploader()
+ self.units = ("V",)
+ self.labels = ("y axis",)
+ self.setpoints = (np.linspace(20,50,1),)
+ def play(self, idx):
+ time.sleep(0.01)
+ pass
+
+
+ def upload(self, idx):
+ pass
+ class test_AWG_sequence1D(object):
+ """docstring for test_AWG_sequence"""
+ def __init__(self):
+ super(test_AWG_sequence1D, self).__init__()
+ self.shape = (50, )
+ self.uploader = uploader()
+ self.units = ("V",)
+ self.labels = ("y axis",)
+ self.setpoints = (np.linspace(20,50,50),)
+ def play(self, idx):
+ time.sleep(0.01)
+ pass
+
+
+ def upload(self, idx):
+ pass
+ class test_AWG_sequence2D(object):
+ """docstring for test_AWG_sequence"""
+ def __init__(self):
+ super(test_AWG_sequence2D, self).__init__()
+ self.shape = (50, 50)
+ self.units = ("V", "V")
+ self.labels = ("x axis", "y axis")
+ self.setpoints = (np.linspace(20,50,50), np.linspace(50,125,50))
+ self.uploader = uploader()
+
+ def play(self, idx):
+ time.sleep(0.01)
+ pass
+
+
+ def upload(self, idx):
+ pass
+ class dummy_parameter(Parameter):
+ def __init__(self, name, label=None, unit=None):
+
+ super().__init__(name=name,
+ instrument=None,
+ labels=( "digitzer_response"),
+ units=("unit1" ))
+ class dummy_multi_parameter(MultiParameter):
+ def __init__(self, name, label=None, unit=None):
+
+ super().__init__(name=name,
+ instrument=None,
+ names=("test12","test1234"),
+ shapes=( (200, ) , (200, ), ),
+ labels=( "digitzer_response", "D2"),
+ units=("unit1", "unit2"), )
+ self.setpoints = ( (np.linspace(70,500,200), ), (np.linspace(70,500,200), ))
+ self.setpoint_shapes = ( (200, ), (200, ))
+ self.setpoint_labels = ( ("I channel", ), ('Q channel', ))
+ self.setpoint_units = ( ("mV", ), ("mV", ))
+ self.setpoint_names = ( ("test_name", ), ("testname_2", ))
+ self.i = 2
+ def get_raw(self):
+ self.i +=1
+ return (np.linspace(0,500,200)+self.i, np.linspace(0,500,200)+self.i+100)
+ class dummy_multi_parameter_2dawg(MultiParameter):
+ def __init__(self, name, label=None, unit=None):
+
+ super().__init__(name=name,
+ instrument=None,
+ names=("test12","test1234"),
+ shapes=( tuple() , tuple() ),
+ labels=( "digitzer_response", "D2"),
+ units=("unit1", "unit2"), )
+ self.setpoints = ( tuple(), tuple())
+ self.setpoint_shapes = ( tuple(), tuple())
+ self.setpoint_labels = ( ("I channel", ), ('Q channel', ))
+ self.setpoint_units = ( ("mV", ), ("mV", ))
+ self.setpoint_names = ( ("I_channel", ), ("Q_channel", ))
+ self.i = 2
+ def get_raw(self):
+ self.i +=1
+ return (self.i, self.i+100)
+ class uploader(object):
+ """docstring for uploader"""
+ def __init__(self, ):
+ super(uploader, self).__init__()
+
+ def wait_until_AWG_idle(self):
+ '''
+ check if the AWG is doing playback, when done, release this function
+ '''
+ time.sleep(0.01)
+ pass
+
+ measurment_parameter = dummy_multi_parameter("digitzer_1", label="qubit_1 (spin up)", unit="%")
+ measurment_parameter2D = dummy_multi_parameter_2dawg("digitzer_1", label="qubit_1 (spin up)", unit="%")
+
+ awg_sequence0D = test_AWG_sequence0D()
+ awg_sequence1D = test_AWG_sequence1D()
+ awg_sequence2D = test_AWG_sequence2D()
+ test = pulselib_2_qcodes(awg_sequence0D)
+ print(test)
\ No newline at end of file
diff --git a/core_tools/sweeps/sweep_utility.py b/core_tools/sweeps/sweep_utility.py
new file mode 100644
index 00000000..52f3c871
--- /dev/null
+++ b/core_tools/sweeps/sweep_utility.py
@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from qcodes import Parameter
+
+class KILL_EXP(Exception):
+ pass
+
+@dataclass
+class sweep_info():
+ '''
+ data class that hold the sweep info for one of the paramters.
+ -- also contains a looper - (should this one move to somewhere else?)
+ '''
+ _param : Parameter = None
+ start : float = 0
+ stop : float = 0
+ n_points : int = 50
+ delay : float = 0
+
+ def __post_init__(self):
+ self.param = self._param
+
+ @property
+ def param(self):
+ return self._param
+
+ @param.setter
+ def param(self, input_param):
+ self.param_val = input_param.get()
+ self._param = input_param
+
+ def reset_param(self):
+ self._param.set(self.param_val)
+
+def get_measure_data(m_instr):
+ '''
+ measure date for given paramters in m_instr
+
+ Args:
+ m_instr (list<qc.Parameter>) : list with parameters to be measured
+ Returns
+ my_data (list<qc.Parameter>), np.ndarray/str/float/int>)
+ '''
+ my_data = []
+ for instr in m_instr:
+ my_data.append( (instr, instr.get()))
+
+ return my_data
+
+class PulseLibParameter(Parameter):
+ setpoints = None
+ flat_index = 0
+
+ def add_setpoints(self, setpoints, sequencer, lowest_level):
+ self.setpoints = setpoints
+ self.sequencer = sequencer
+ self.lowest_level = lowest_level
+
+ def get_raw(self):
+ current_val = self.setpoints[self.flat_index%len(self.setpoints)]
+
+ self.flat_index += 1
+ if self.flat_index > np.prod(self.sequencer.shape):
+ self.flat_index = 0
+
+ return current_val
+
+ def set_raw(self, value):
+ if self.lowest_level:
+ if self.flat_index == 0:
+ self.sequencer.upload(np.unravel_index(flat_index, self.sequencer.shape))
+
+ index = np.unravel_index(flat_index, self.shape)
+ self.sequencer.play(index)
+
+ if flat_index < np.prod(self.shape) - 1:
+ self.sequencer.upload(np.unravel_index(flat_index+1, self.shape))
+
+ self.sequencer.uploader.wait_until_AWG_idle()
+
+ '''
+ @ sander, how can we make sure that a unused upload is removed when the garbage collector collects this?
+ (e.g. when a set is performed to reset parameters -- normally this does not happen, but user might accidentatly do this.)
+ '''
+
+def pulselib_2_qcodes(awg_sequence):
+ '''
+ convert pulse sequencer object in qcodes parameters that are usable in sweeps.
+
+ Args:
+ awg_sequence (pulselib.sequencer.sequencer) : sequence object
+
+ Returns:
+ set_param (list<PulseLibParameter>) : set paramters for the pulselib to be used in the sweep
+ '''
+ set_param = list()
+ for i in range(len(awg_sequence.shape)):
+ param = PulseLibParameter(name = awg_sequence.labels[i].replace(" ", "_"), label=awg_sequence.labels[i], unit= awg_sequence.units[i])
+ param.add_setpoints(awg_sequence.setpoints[i], awg_sequence, False)
+ set_param.append(sweep_info(param, n_points = len(awg_sequence.setpoints[i])))
+
+ set_param[0].param.lowest_level=True
+
+ return set_param[::-1]
diff --git a/core_tools/sweeps/sweeps.py b/core_tools/sweeps/sweeps.py
new file mode 100644
index 00000000..8dac614c
--- /dev/null
+++ b/core_tools/sweeps/sweeps.py
@@ -0,0 +1,179 @@
+from qcodes.instrument.specialized_parameters import ElapsedTimeParameter
+from qcodes.dataset.measurements import Measurement
+from pulse_lib.sequencer import sequencer
+
+from core_tools.sweeps.sweep_utility import pulselib_2_qcodes, sweep_info, get_measure_data, KILL_EXP
+from core_tools.job_mgnt.job_meta import job_meta
+
+import numpy as np
+import time
+
+class scan_generic(metaclass=job_meta):
+ '''
+ function that handeles the loop action and defines the run class.
+ '''
+ def __init__(self, *args, reset_param=False):
+ '''
+ init of the scan function
+
+ Args:
+ args (*list) : provide here the sweep info and meaurment parameters
+ reset_param (bool) : reset the setpoint parametes to their original value after the meaurement
+ '''
+ self.meas = Measurement()
+
+ self.set_vars = []
+ self.m_instr = []
+ self.reset_param = reset_param
+
+ set_points = []
+ for arg in args:
+ if isinstance(arg, sweep_info):
+ self.meas.register_parameter(arg.param)
+ self.set_vars.append(arg)
+ set_points.append(arg.param)
+ elif isinstance(arg, sequencer):
+ set_vars_pulse_lib = pulselib_2_qcodes(arg)
+ for var in set_vars_pulse_lib:
+ self.meas.register_parameter(var.param)
+ set_points.append(var.param)
+ self.set_vars += set_vars_pulse_lib
+ else:
+ self.m_instr.append(arg)
+ for instr in self.m_instr:
+ self.meas.register_parameter(instr, setpoints=tuple(set_points[::-1]))
+
+ self.n_tot = 1
+ for swp_info in self.set_vars:
+ self.n_tot *= swp_info.n_points
+
+ def run(self):
+ '''
+ run function
+ -- starts the meaurement and saves the data
+ -- optionally also resets the paramters
+ -- wrapped by the job_meta class (allows for progress bar to appear)
+ '''
+ with self.meas.run() as datasaver:
+ self._loop(self.set_vars, self.m_instr, tuple(), datasaver)
+ dataset = datasaver.dataset
+
+ if self.reset_param:
+ for param in self.set_vars:
+ param.reset_param()
+
+ return dataset
+
+ def _loop(self, set_param, m_instr, to_save, datasaver):
+ if len(set_param) == 0:
+ if self.KILL == False:
+ datasaver.add_result(*to_save, *get_measure_data(m_instr))
+ self.n += 1
+ else:
+ raise KILL_EXP
+ else:
+ param_info = set_param[0]
+ for value in np.linspace(param_info.start, param_info.stop, param_info.n_points):
+ if not isinstance(param_info.param, ElapsedTimeParameter):
+ param_info.param(value)
+ time.sleep(param_info.delay)
+ self._loop(set_param[1:], m_instr, to_save + ((param_info.param, param_info.param()),), datasaver)
+
+
+def do0D(*m_instr):
+ '''
+ do a 0D scan
+
+ Args:
+ m_instr (*list) : list of parameters to measure
+ '''
+ return scan_generic(*m_instr, reset_param=False)
+
+def do1D(param, start, stop, n_points, delay, *m_instr, reset_param=False):
+ '''
+ do a 1D scan
+
+ Args:
+ param (qc.Parameter) : parameter to be swept
+ start (float) : start value of the sweep
+ stop (float) : stop value of the sweep
+ delay (float) : time to wait after the set of the parameter
+ m_instr (*list) : list of parameters to measure
+ reset_param (bool) : reset the setpoint parametes to their original value after the meaurement
+ '''
+ m_param = sweep_info(param, start, stop, n_points, delay)
+ return scan_generic(m_param, *m_instr, reset_param=reset_param)
+
+def do2D(param_1, start_1, stop_1, n_points_1, delay_1,
+ param_2, start_2, stop_2, n_points_2, delay_2, *m_instr, reset_param=False):
+ '''
+ do a 2D scan
+
+ Args:
+ param_1 (qc.Parameter) : parameter to be swept
+ start_1 (float) : start value of the sweep
+ stop_1 (float) : stop value of the sweep
+ delay_1 (float) : time to wait after the set of the parameter
+ param_2 (qc.Parameter) : parameter to be swept
+ start_2 (float) : start value of the sweep
+ stop_2 (float) : stop value of the sweep
+ delay_2 (float) : time to wait after the set of the parameter
+ m_instr (*list) : list of parameters to measure
+ reset_param (bool) : reset the setpoint parametes to their original value after the meaurement
+ '''
+ m_param_1 = sweep_info(param_1, start_1, stop_1, n_points_1, delay_1)
+ m_param_2 = sweep_info(param_2, start_2, stop_2, n_points_2, delay_2)
+ return scan_generic(m_param_2, m_param_1, *m_instr, reset_param=reset_param)
+
+if __name__ == '__main__':
+
+ import os
+ import datetime
+
+ import numpy as np
+ import scipy.optimize as opt
+ import matplotlib.pyplot as plt
+
+ import qcodes as qc
+ from qcodes.dataset.plotting import plot_dataset
+ from qcodes.dataset.data_set import load_by_run_spec
+ from qcodes.dataset.sqlite.database import initialise_or_create_database_at
+ from qcodes.dataset.experiment_container import load_or_create_experiment
+ from qcodes.tests.instrument_mocks import MockParabola
+
+ station = qc.station.Station()
+ station.add_component(MockParabola(name='MockParabola'))
+
+ class MyCounter(qc.Parameter):
+ def __init__(self, name):
+ # only name is required
+ super().__init__(name, label='Times this has been read',
+ docstring='counts how many times get has been called '
+ 'but can be reset to any integer >= 0 by set')
+ self._count = 0
+
+ # you must provide a get method, a set method, or both.
+ def get_raw(self):
+ self._count += 1
+ return self._count
+
+ def set_raw(self, val):
+ self._count = val
+
+
+ now = str(datetime.datetime.now())
+ tutorial_db_path = os.path.join(os.getcwd(), 'linking_datasets_tutorial.db')
+ initialise_or_create_database_at(tutorial_db_path)
+ load_or_create_experiment('tutorial ' + now, 'no sample')
+ my_param = MyCounter('test_instr')
+ from qcodes.instrument.specialized_parameters import ElapsedTimeParameter
+
+ x = qc.Parameter(name='x', label='Voltage_x', unit='V',
+ set_cmd=None, get_cmd=None)
+ y = qc.Parameter(name='y', label='Voltage_y', unit='V',
+ set_cmd=None, get_cmd=None)
+ timer = ElapsedTimeParameter('time')
+ # do0D(my_param).run()
+ # do1D(x, 0, 100, 50, 0.1 , my_param, reset_param=True).run()
+ do2D(x, 0, 20, 20, 0.0, y, 0, 80, 30, 0.01, my_param).run()
+ do2D(x, 0, 20, 20, 0.0, timer, 0, 80, 30, 0.1, my_param).run()
\ No newline at end of file
diff --git a/core_tools/sweeps/Modulated_scans/DEMOD_tests.py b/core_tools/sweeps/sweeps_old/Modulated_scans/DEMOD_tests.py
similarity index 100%
rename from core_tools/sweeps/Modulated_scans/DEMOD_tests.py
rename to core_tools/sweeps/sweeps_old/Modulated_scans/DEMOD_tests.py
diff --git a/core_tools/sweeps/Modulated_scans/__init__.py b/core_tools/sweeps/sweeps_old/Modulated_scans/__init__.py
similarity index 100%
rename from core_tools/sweeps/Modulated_scans/__init__.py
rename to core_tools/sweeps/sweeps_old/Modulated_scans/__init__.py
diff --git a/core_tools/sweeps/Modulated_scans/mod_test.py b/core_tools/sweeps/sweeps_old/Modulated_scans/mod_test.py
similarity index 100%
rename from core_tools/sweeps/Modulated_scans/mod_test.py
rename to core_tools/sweeps/sweeps_old/Modulated_scans/mod_test.py
diff --git a/core_tools/sweeps/sweeps_old/__init__.py b/core_tools/sweeps/sweeps_old/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/core_tools/sweeps/exp_readout_runner.py b/core_tools/sweeps/sweeps_old/exp_readout_runner.py
similarity index 100%
rename from core_tools/sweeps/exp_readout_runner.py
rename to core_tools/sweeps/sweeps_old/exp_readout_runner.py
diff --git a/core_tools/sweeps/pulse_lib_sweep.py b/core_tools/sweeps/sweeps_old/pulse_lib_sweep.py
similarity index 100%
rename from core_tools/sweeps/pulse_lib_sweep.py
rename to core_tools/sweeps/sweeps_old/pulse_lib_sweep.py
--
GitLab