def test_multi_parameter(self):
p = qcodes.Parameter('p', set_cmd=None)
q = qcodes.Parameter('q', set_cmd=None)
mp = MultiParameter('multi_param', [p, q])
mp.set([1, 2])
_ = mp.get()
mp = CombiParameter('multi_param', [p, q])
mp.set([1, 3])
v = mp.get()
self.assertTrue(v == 2)
def test_list_of_strings(experiment):
"""
Test saving list of strings via DataSaver
"""
p_values = ["X_Y", "X_X", "X_I", "I_I"]
list_of_strings = list(np.random.choice(p_values, (10, )))
p = qc.Parameter('p',
label='String parameter',
unit='',
get_cmd=None,
set_cmd=None,
initial_value='X_Y')
meas = Measurement(experiment)
meas.register_parameter(p, paramtype='text')
with meas.run() as datasaver:
datasaver.add_result((p, list_of_strings))
test_set = load_by_id(datasaver.run_id)
expec_data = np.array([item for item in list_of_strings])
actual_data = test_set.get_parameter_data()["p"]["p"]
try:
np.testing.assert_array_equal(actual_data, expec_data)
finally:
test_set.conn.close()
def wrap_par_set_get(par):
new_par = qc.Parameter(name=par.name, label=par.label, unit=par.unit)
def wrap_set(val):
par.set(val)
par.get()
new_par.set = wrap_set
return new_par
def __init__(self,
gate_names,
gate_values=None,
station=None,
index=None,
minstrument=None,
virt_gates=None):
""" Class representing a sensing dot
We assume the sensing dot can be controlled by two barrier gates and a single plunger gate.
An instrument to measure the current through the dot is provided by the minstrument argument.
Args:
gate_names (list): gates to be used
gate_values (array or None): values to be set on the gates
station (Qcodes station)
minstrument (tuple or str or Parameter): measurement instrument to use. tuple of instrument and channel
index
index (None or int): deprecated
fpga_ch (deprecated, int): index of FPGA channel to use for readout
virt_gates (None or object): virtual gates object (optional)
boxcar_filter_kernel_size (int): size of boxcar filter kernel to use in post-processing
"""
self.verbose = 1
self.gg = gate_names
if gate_values is None:
gate_values = [station.gates.get(g) for g in self.gg]
self.sdval = gate_values
self.targetvalue = np.NaN
self.boxcar_filter_kernel_size = 1
self._selected_peak = None
self._detune_axis = np.array([1, -1])
self._detune_axis = self._detune_axis / np.linalg.norm(
self._detune_axis)
self._debug = {} # store debug data
self.name = '-'.join([s for s in self.gg])
self.goodpeaks = None
self.station = station
self.index = index
self.minstrument = minstrument
if index is not None:
raise Exception('use minstrument argument')
self.virt_gates = virt_gates
self.data = {}
self.plunger = qcodes.Parameter('plunger',
get_cmd=self.plungervalue,
set_cmd=self._set_plunger)
# values for measurement
if index is not None:
self.valuefunc = station.components['keithley%d' %
index].amplitude.get
else:
self.valuefunc = None
def wrap_par_remainder(par, remainder=1):
new_par = qc.Parameter(name=par.name, label=par.label, unit=par.unit)
def wrap_set(val):
val = val % remainder
par.set(val)
par.get()
new_par.set = wrap_set
return new_par
class TestNoSorting(TestCase):
"""
(WilliamHPNielsen): I'm not too sure where this test belongs... It tests
that parameters with non-sortable keys can be saved using the gnuplot
formatter, so I guess it goes here.
"""
param = qcodes.Parameter(name='mixed_val_mapping_param',
get_cmd=lambda: np.random.randint(1, 3),
val_mapping={1: 1, '2': 2}
)
def test_can_measure(self):
qcodes.measure.Measure(self.param).run()
def test_string_and_date_data_in_array(experiment, p_values):
p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None,
set_cmd=None, initial_value=p_values)
meas = Measurement(experiment)
meas.register_parameter(p, paramtype='array')
with meas.run() as datasaver:
datasaver.add_result((p, p.get()))
actual_data = datasaver.dataset.get_parameter_data()["p"]["p"]
np.testing.assert_array_equal(
actual_data,
p_values.reshape((1, *p_values.shape))
)
def test_datasaver_foul_input(experiment):
meas = Measurement()
meas.register_custom_parameter('foul',
label='something unnatural',
unit='Fahrenheit')
foul_stuff = [qc.Parameter('foul'), set((1, 2, 3))]
with meas.run() as datasaver:
for ft in foul_stuff:
with pytest.raises(ValueError):
datasaver.add_result(('foul', ft))
def test_string(experiment):
"""
Test that we can save text into database via Measurement API
"""
p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None,
set_cmd=None, initial_value='some text')
meas = Measurement(experiment)
meas.register_parameter(p, paramtype='text')
with meas.run() as datasaver:
datasaver.add_result((p, "some text"))
test_set = load_by_id(datasaver.run_id)
assert test_set.get_data("p") == [["some text"]]
def test_string_with_wrong_paramtype(experiment):
"""
Test that an exception occurs when saving string data if when registering a
string parameter the paramtype was not set to 'text'
"""
p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None,
set_cmd=None, initial_value='some text')
meas = Measurement(experiment)
# intentionally forget `paramtype='text'`, so that the default 'numeric'
# is used, and an exception is raised later
meas.register_parameter(p)
with meas.run() as datasaver:
msg = re.escape('Parameter p is of type "numeric", but got a '
"result of type <U9 (some text).")
with pytest.raises(ValueError, match=msg):
datasaver.add_result((p, "some text"))
def test_string_with_wrong_paramtype(experiment):
"""
Test that an exception occurs when saving string data if when registering a
string parameter the paramtype was not set to 'text'
"""
p = qc.Parameter('p', label='String parameter', unit='', get_cmd=None,
set_cmd=None, initial_value='some text')
meas = Measurement(experiment)
# intentionally forget `paramtype='text'`, so that the default 'numeric'
# is used, and an exception is raised later
meas.register_parameter(p)
with meas.run() as datasaver:
msg = "It is not possible to save a string value for parameter 'p' " \
"because its type class is 'numeric', not 'text'."
with pytest.raises(ValueError, match=msg):
datasaver.add_result((p, "some text"))
self.i = 2
def get_raw(self):
self.i += 1
return (self.i, self.i + 100)
now = str(datetime.datetime.now())
path = os.path.join(os.getcwd(), 'test.db')
initialise_or_create_database_at(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')
my_param_multi_test = dummy_multi_parameter_2dawg('param')
from core_tools.GUI.keysight_videomaps.data_getter.scan_generator_Virtual import construct_1D_scan_fast, construct_2D_scan_fast, fake_digitizer
param_1D = construct_1D_scan_fast("P2", 10, 10, 5000, True, None,
fake_digitizer('test'))
param_2D = construct_2D_scan_fast('P2', 10, 10, 'P5', 10, 10, 50000, True,
None, fake_digitizer('test'))
class SoftSweepCtl(acquisition_controllers.PostIQCtl):
"""
An acquisition controller that allows fast software spec.
The frequencies can be iterated through without stopping the alazar acquisition.
Returns one IQ value per frequency.
NOTE: you probably want to use at least 2 or 3 averages per point for this to work
without glitches.
Set the total number of buffers, and the buffers per block to determine the number of points
and the number of averages, n_avgs = buffers / buffers_per_block.
You will want to run this when the AWG runs a sequence that triggers the alazar n_avgs times in a row,
but each of these trigger trains must be triggered (i.e., AWG is waiting for a trigger).
Of course the trigger interval needs to slightly exceed the acquisition time per record, as usual.
For determining how to advance from one sweep point to the next, you can specify the function
``next_point_trigger_func()``. Per default this does nothing, but the user can set it to a
function that could play a trigger on the AWG. This depends on thow the setup is hooked up.
"""
sweep_vals = np.array([])
sweep_param = qcodes.Parameter('dummy_parameter', set_cmd=None)
settling_time = 0
verbose = True
@staticmethod
def next_point_trigger_func(): return None
def __init__(self, *arg, **kw):
super().__init__(*arg, **kw)
self._step = 0
def _settle(self):
if self.settling_time > 0:
time.sleep(self.settling_time)
def _perform_step(self, num):
"""
Set generator to the i-th point whenever buffer_number // buffers_per_block increases.
Takes into account that calls to this function lag 2 behind the actual acquisition.
"""
t0 = time.perf_counter()
awg = qcodes.Station.default.awg
# we have to increase num by 2: by the time this is called, the
# alazar is already measuring the buffer that's 2 after the received one.
# this is just a reality of the alazar we have to live with here.
if ((num+2) % self.buffers_per_block()) == 0:
self._step += 1
if self._step < len(self.sweep_vals):
if self.verbose:
print(f'Point {self._step + 1} ({self.sweep_vals[self._step]:1.5e})'
+ 10 * "", end='\r')
self.sweep_param(self.sweep_vals[self._step])
self._settle()
else:
if self.verbose:
print('Done!', end='\r')
self.next_point_trigger_func()
self.step_times[num] = (time.perf_counter() - t0)*1e3
def pre_acquire(self):
"""
Starts the acquisition. Sets the generator to the first point, triggers the AWG for the first time.
"""
super().pre_acquire()
self.step_times = np.zeros(self.buffers_per_acquisition(), dtype=float)
self.sweep_param(self.sweep_vals[0])
self._settle()
self._step = 0
self.next_point_trigger_func()
def buffer_done_callback(self, buffernum):
"""
This function is called every time the alazar returns buffer data.
"""
nextstep = buffernum
self._perform_step(nextstep)
# v.X.scale = 1e8 * (v.amplitude.get()/lockinAmplitudeDivider) * 3.874e-5
# v.X.label = lockinLabels[i]
# define extra functions
#Qdevfit = qdev_fitter()
# IEc
def Q1Plungers_set(value):
qdac.Q1iP(value)
qdac.Q1gP(value)
Q1Plungers = qc.Parameter('Q1Plungers',
label='Q1Plungers',
unit='V',
set_cmd=Q1Plungers_set)
def Q2Plungers_set(value):
qdac.Q2iP(value)
qdac.Q2gP(value)
Q2Plungers = qc.Parameter('Q2Plungers',
label='Q2 Plungers',
unit='V',
set_cmd=Q2Plungers_set)
def Q4Plungers_set(value):
from qcodes.instrument.parameter import _BaseParameter
from qcodes.data.data_set import DataSet
from silq.tools.parameter_tools import create_set_vals
from silq.tools.general_tools import SettingsClass, get_truth, \
clear_single_settings, JSONEncoder
__all__ = [
'Condition', 'TruthCondition', 'ConditionSet', 'Measurement',
'Loop0DMeasurement', 'Loop1DMeasurement', 'Loop2DMeasurement'
]
logger = logging.getLogger(__name__)
_dummy_parameter = qc.Parameter(name='msmt_idx',
set_cmd=None,
label='Measurement idx')
class Condition:
def __init__(self, **kwargs):
pass
def _JSONEncoder(self):
"""
Converts to JSON encoder for saving metadata
Returns:
JSON dict
"""
return JSONEncoder(self)
while True:
target = (counter % (no_of_pulses)) + 2
awg.set_sqel_goto_target_index(1, target)
counter += 1
yield
stepper = step_awg_to_next_pulse(awg, len(hightimes))
def step_setter(value):
next(stepper)
step_param = qc.Parameter('Pulse width',
label='Pulse width',
unit='s',
set_cmd=step_setter)
#%%
# At least this code must be run on every measurement
# re-initialise the counter
stepper = step_awg_to_next_pulse(awg, len(hightimes))
step_param.set = step_setter
def make_things_right():
prepareZIUHFLI(zi,
demod_freq,
