def test_revert_1D_twice(self):
arrs = {}
with Measurement("revert_1D_twice") as msmt:
p_measure1 = Parameter('p_measure1', set_cmd=None)
p_measure2 = Parameter('p_measure2', set_cmd=None)
p_sweep = Parameter('p_sweep', set_cmd=None)
for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))):
arr1 = arrs.setdefault(msmt.action_indices, np.zeros(msmt.loop_shape))
p_measure1(1)
arr1[k] = msmt.measure(p_measure1)
arr2 = arrs.setdefault(msmt.action_indices, np.zeros(msmt.loop_shape))
p_measure2(2)
arr2[k] = msmt.measure(p_measure2)
if k == 5:
msmt.revert(2)
p_measure1(3)
p_measure2(4)
arr1[k] = msmt.measure(p_measure1)
arr2[k] = msmt.measure(p_measure2)
verify_msmt(msmt, arrs)
def test_double_multi_parameter(self):
multi_parameter1 = MultiParameterTest("multi_param1")
multi_parameter2 = MultiParameterTest("multi_param2")
multi_parameter2.values = (2,3,4)
sweep_param = Parameter("sweep_param", set_cmd=None)
with Measurement("test_double_multi_parameter") as msmt:
for val in Sweep(sweep_param.sweep(0, 10, 1)):
msmt.measure(multi_parameter1)
msmt.measure(multi_parameter2)
self.assertEqual(msmt.data_groups[(0, 0)].name, "multi_param1")
self.assertEqual(msmt.data_groups[(0, 1)].name, "multi_param2")
verification_arrays = {
(0, 0, 0): [1] * 11,
(0, 0, 1): [2] * 11,
(0, 0, 2): [3] * 11,
(0, 1, 0): [2] * 11,
(0, 1, 1): [3] * 11,
(0, 1, 2): [4] * 11,
}
self.assertListEqual(list(verification_arrays), list(msmt.data_arrays))
verify_msmt(msmt, verification_arrays=verification_arrays)
def test_mask_parameter_attr(self):
p = Parameter("masking_param", set_cmd=None, initial_value=1)
p.x = 1
with Measurement("mask_parameter_attr") as msmt:
self.assertEqual(p.x, 1)
msmt.mask(p, x=2)
self.assertEqual(len(msmt._masked_properties), 1)
self.assertDictEqual(
msmt._masked_properties[0],
{
"type": "attr",
"obj": p,
"attr": "x",
"original_value": 1,
"value": 2,
},
)
for k in Sweep(range(10), "repetition"):
msmt.measure({"a": 3, "b": 4}, "acquire_values")
self.assertEqual(p.x, 2)
self.assertEqual(p(), 1)
self.assertEqual(p.x, 2)
self.assertEqual(p.x, 1)
self.assertEqual(len(msmt._masked_properties), 0)
def test_scan1D(self, verbose=0):
p = Parameter('p', set_cmd=None)
q = Parameter('q', set_cmd=None)
r = VoltageDivider(p, 4)
_ = MultiParameter(instrumentName('multi_param'), [p, q])
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
if verbose:
print('test_scan1D: running scan1D')
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [q, r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': 'dac1', 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]})
_ = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
data = scan1D(station, scanjob, liveplotwindow=False, verbose=0, extra_metadata={'hi': 'world'})
self.assertTrue('hi' in data.metadata)
gates.close()
def test_old_loop_1D_2D(self):
self.p_sweep2 = Parameter("p_sweep2", set_cmd=None)
loop = Loop(self.p_sweep.sweep(0, 5, 1)).each(
self.p_measure, Loop(self.p_sweep2.sweep(0, 5, 1)).each(self.p_measure)
)
loop.run(name="old_loop_1D_2D", thread=False)
def test_revert_multi_parameter(self):
multi_parameter = MultiParameterTest("multi_param")
sweep_param = Parameter("sweep_param", set_cmd=None)
with Measurement("test_multi_parameter") as msmt:
for k, val in enumerate(Sweep(sweep_param.sweep(0, 10, 1))):
msmt.measure(multi_parameter)
if k == 4:
msmt.revert()
multi_parameter.values = (2,3,4)
msmt.measure(multi_parameter)
multi_parameter.values = (1,2,3)
self.assertEqual(msmt.data_groups[(0, 0)].name, "multi_param")
verification_arrays = {
(0, 0, 0): [1] * 11,
(0, 0, 1): [2] * 11,
(0, 0, 2): [3] * 11,
}
for key, val in verification_arrays.items():
val[4] += 1
verify_msmt(msmt, verification_arrays=verification_arrays)
def init():
a_property = Parameter('a_property', set_cmd=None, get_cmd=None,
initial_value=0)
another_property = Parameter('another_property', set_cmd=None, get_cmd=None,
initial_value='abc', vals=validators.Strings())
station = Station(a_property, another_property)
return station
def test_with_set_conversion_and_initial_value_given():
value = 36
p = Parameter('testparam', set_cmd=None, get_cmd=None)
c = ConversionParameter('test_conversion_parameter',
p,
lambda x: x,
set_conv=lambda x: x * 2,
initial_value=value)
assert value * 2 == p.get_latest()
assert value == c.get_latest()
def test_measurement_except_final_actions_no_fail(self):
p_except = Parameter(initial_value=42, set_cmd=None)
p_final = Parameter(initial_value=41, set_cmd=None)
with Measurement('measurement_fail') as msmt:
msmt.except_actions.append(partial(p_except, 43))
msmt.final_actions.append(partial(p_final, 40))
self.assertEqual(p_except(), 42)
self.assertEqual(p_final(), 40)
def test_with_set_conversion():
p = Parameter('testparam', set_cmd=None, get_cmd=None)
c = ConversionParameter('test_conversion_parameter',
p,
lambda x: x,
set_conv=lambda x: x * 2,
unit='V')
new_value = 25
c.set(new_value)
assert new_value * 2 == p.get_latest()
assert new_value == c.get_latest()
def test_simple_measurement_verification_no_error_parameter(self):
msmt_param = Parameter("msmt_param", get_cmd=np.random.rand)
msmt_param2 = Parameter("msmt_param", get_cmd=np.random.rand)
# Notice we give the same name
with Measurement(
"test_simple_measurement_verification_no_error_parameter"
) as msmt:
for k, _ in enumerate(Sweep(range(10), "sweep_param")):
if k < 7:
msmt.measure(msmt_param)
else:
msmt.measure(msmt_param2)
def test_simple_measurement_verification_error_parameter(self):
msmt_param = Parameter("msmt_param", get_cmd=np.random.rand)
different_msmt_param = Parameter("different_msmt_param", get_cmd=np.random.rand)
with self.assertRaises(RuntimeError):
with Measurement(
"test_simple_measurement_verification_error_parameter"
) as msmt:
for k, _ in enumerate(Sweep(range(10), "sweep_param")):
if k < 7:
msmt.measure(msmt_param)
else:
msmt.measure(different_msmt_param)
def test_measurement_except_final_actions(self):
p_except = Parameter(initial_value=42, set_cmd=None)
p_final = Parameter(initial_value=41, set_cmd=None)
with self.assertRaises(RuntimeError):
with Measurement('measurement_fail') as msmt:
msmt.except_actions.append(partial(p_except, 43))
msmt.final_actions.append(partial(p_final, 40))
raise RuntimeError('help')
self.assertEqual(p_except(), 43)
self.assertEqual(p_final(), 40)
def test_measure_node_dict(self):
arrs = {}
node = self.DictResultsNode("measurable_node")
p_sweep = Parameter("sweep", set_cmd=None)
with Measurement("measure_node") as msmt:
for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))):
results = msmt.measure(node.get)
# Save results to verification arrays
for kk, result in enumerate(results.values()):
arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape))
arrs[(0, 0, kk)][k] = result
def _mk_frequency(self, max_frequency: float) -> Parameter:
frequency = Parameter(
name="frequency",
instrument=self,
label="Frequency",
unit="Hz",
vals=validators.Numbers(min_value=250e3, max_value=max_frequency),
get_cmd="RA:frequency",
get_parser=int,
set_cmd=self._set_frequency,
set_parser=lambda freq: str(int(freq)),
)
frequency.__doc__ = "The RF Frequency in Hz."
return frequency
def _mk_sweep_step_frequency(self, max_frequency: float) -> Parameter:
sweep_step_frequency = Parameter(
name="sweep_step_frequency",
instrument=self,
label="Sweep step",
unit="Hz",
vals=validators.Numbers(min_value=0, max_value=max_frequency),
get_cmd=f"RA:{_CMD_TO_JSON_MAPPING['S3']}",
get_parser=int,
set_cmd="S3{}",
set_parser=lambda freq: str(int(freq)),
)
sweep_step_frequency.__doc__ = "Sweep step frequency in Hz."
return sweep_step_frequency
def test_new_loop_2D(self):
arrs = {}
self.p_sweep2 = Parameter("p_sweep2", set_cmd=None)
with Measurement("new_loop_1D_double") as msmt:
for k, val in enumerate(Sweep(self.p_sweep2.sweep(0, 1, 0.1))):
for kk, val2 in enumerate(Sweep(self.p_sweep.sweep(0, 1, 0.1))):
self.assertEqual(msmt.loop_shape, (11, 11))
arr = arrs.setdefault(
msmt.action_indices, np.zeros(msmt.loop_shape)
)
arr[k, kk] = msmt.measure(self.p_measure)
verify_msmt(msmt, arrs)
def test_measure_parameter_array_2D(self):
arrs = {}
p_measure = Parameter("p_measure", get_cmd=lambda: np.random.rand(5, 12))
with Measurement("new_loop_parameter_array_2D") as msmt:
for k, val in enumerate(Sweep(self.p_sweep.sweep(0, 1, 0.1))):
arr = arrs.setdefault(
msmt.action_indices, np.zeros(msmt.loop_shape + (5, 12))
)
result = msmt.measure(p_measure)
arr[k] = result
dataset = verify_msmt(msmt, arrs)
# Perform additional test on set arrays
set_array = np.broadcast_to(np.arange(5), (11, 5))
np.testing.assert_array_almost_equal(
dataset.arrays["p_measure_set0_0_0"], set_array
)
set_array = np.broadcast_to(np.arange(12), (11, 5, 12))
np.testing.assert_array_almost_equal(
dataset.arrays["p_measure_set1_0_0_0"], set_array
)
def test_dict_function_custom_name(self):
arrs = {}
p_sweep = Parameter("sweep", set_cmd=None)
with Measurement("measure_node") as msmt:
for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))):
results = msmt.measure(self.dict_function, name="custom_name")
# Save results to verification arrays
for kk, result in enumerate(results.values()):
arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape))
arrs[(0, 0, kk)][k] = result
self.assertEqual(msmt.data_groups[(0, 0)].name, "custom_name")
verify_msmt(msmt, arrs)
def test_param_setter():
p = Parameter("p", unit="P", get_cmd=None, set_cmd=None)
strr = parameter_setter(p)
assert hasattr(strr, "getter_setter_decorated")
_strr, table = strr()
assert _strr(0) == {"p": 0}
assert p.get() == 0
table.resolve_dependencies()
assert table.nests == [["p"]]
param_spec, = table.param_specs
assert param_spec.name == "p"
assert param_spec.unit == "P"
def __init__(self, awg, awg_number=0):
""" Implements the common functionality of the AwgCommon for the Zurich Instruments HDAWG8 to be controlled by
the virtual AWG.
Note:
Channels are zero based so channel '0' is output '1' on the physical device.
Note:
This backend is setup to work with grouping 1x8 where one awg controls 8 outputs.
Args:
awg (ZIHDAWG8): Instance of the QCoDeS ZIHDAWG8 driver.
awg_number (int): The number of the AWG that is to be controlled. The ZI HDAWG8 has 4 AWGs and the default
one is the first one (index 0).
"""
super().__init__('ZIHDAWG8',
channel_numbers=list(range(0, 8)),
marker_numbers=list(range(0, 8)))
if type(awg).__name__ is not self._awg_name:
raise AwgCommonError('The AWG does not correspond with {}'.format(
self._awg_name))
self.__awg = awg
self.__awg_number = awg_number
self.__settings = {
'sampling_rate':
Parameter(name='sampling_rate',
unit='GS/s',
set_cmd=self.update_sampling_rate,
get_cmd=self.retrieve_sampling_rate)
}
def test_mask_parameters_in_node(self):
node = ParameterNode('node', use_as_attributes=True)
node.p1 = Parameter(set_cmd=None, initial_value=1)
node.p2 = Parameter(set_cmd=None, initial_value=2)
node.p3 = 3
with Measurement('mask_parameters_in_node') as msmt:
msmt.mask(node, p1=42, p2=43, p3=44)
self.assertEqual(node.p1, 42)
self.assertEqual(node.p2, 43)
self.assertEqual(node.p3, 44)
self.assertEqual(node.p1, 1)
self.assertEqual(node.p2, 2)
self.assertEqual(node.p3, 3)
def time_trace(interval_time, total_time=None, stop_condition=None):
start_time = None # Set when we call "generator_function"
if total_time is None:
if stop_condition is None:
raise ValueError("Either specify the total time or the stop "
"condition")
else:
def stop_condition():
global start_time
return time.time() - start_time > total_time
def generator_function():
global start_time
start_time = time.time()
while not stop_condition():
yield time.time() - start_time
time.sleep(interval_time)
time_parameter = Parameter(name="time",
unit="s",
set_cmd=None,
get_cmd=None)
return sweep(time_parameter, generator_function)
def test_scan2D(verbose=0):
p = Parameter('p', set_cmd=None)
q = Parameter('q', set_cmd=None)
r = VoltageDivider(p, 4)
_ = MultiParameter(instrumentName('multi_param'), [p, q])
gates = VirtualIVVI(
name=qtt.measurements.scans.instrumentName('gates'), model=None)
station = qcodes.Station(gates)
station.gates = gates
if verbose:
print('test_scan2D: running scan2D')
scanjob = scanjob_t({'sweepdata': dict(
{'param': p, 'start': 0, 'end': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': q, 'start': 24, 'end': 30, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict({'param': {
'dac1': 1, 'dac2': .1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': {'dac2': 1}, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
scanjob = scanjob_t({'sweepdata': dict(
{'param': {'dac1': 1}, 'start': 0, 'range': 10, 'step': 2}), 'minstrument': [r]})
scanjob['stepdata'] = {'param': MultiParameter('multi_param', [gates.dac2, gates.dac3])}
scanjob['stepvalues'] = np.array([[2 * i, 3 * i] for i in range(10)])
try:
with warnings.catch_warnings():
warnings.simplefilter('ignore')
data = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
except Exception as ex:
print(ex)
warnings.warn('MultiParameter test failed!')
# not supported:
try:
scanjob = scanjob_t({'sweepdata': dict({'param': {
'dac1': 1}, 'start': 0, 'range': 10, 'step': 2, 'wait_time': 0.}), 'minstrument': [r]})
scanjob['stepdata'] = dict(
{'param': q, 'start': 24, 'range': 6, 'end': np.NaN, 'step': 1.})
_ = scan2D(station, scanjob, liveplotwindow=False, verbose=0)
except Exception as ex:
if verbose:
print('combination of Parameter and vector argument not supported')
gates.close()
def generate_DB_file_with_some_runs(version=VERSION):
"""
Generate a .db-file with a handful of runs with some interdependent
parameters
"""
# This function will run often on CI and re-generate the .db-files
# That should ideally be a deterministic action
# (although this hopefully plays no role)
np.random.seed(0)
vNfixturepath = os.path.join(utils.fixturepath, f'version{version}')
os.makedirs(vNfixturepath, exist_ok=True)
path = os.path.join(vNfixturepath, 'some_runs.db')
if os.path.exists(path):
os.remove(path)
from qcodes.dataset.sqlite.database import connect
from qcodes.dataset.measurements import Measurement
from qcodes.dataset.experiment_container import Experiment
from qcodes import Parameter
connect(path)
exp = Experiment(path_to_db=path,
name='experiment_1',
sample_name='no_sample_1')
# Now make some parameters to use in measurements
params = []
for n in range(5):
params.append(
Parameter(f'p{n}',
label=f'Parameter {n}',
unit=f'unit {n}',
set_cmd=None,
get_cmd=None))
# Set up an experiment
meas = Measurement(exp)
meas.register_parameter(params[0])
meas.register_parameter(params[1])
meas.register_parameter(params[2], basis=(params[0], ))
meas.register_parameter(params[3], basis=(params[1], ))
meas.register_parameter(params[4], setpoints=(params[2], params[3]))
# Make a number of identical runs
for _ in range(10):
with meas.run() as datasaver:
for x in np.random.rand(10):
for y in np.random.rand(10):
z = np.random.rand()
datasaver.add_result((params[0], 0), (params[1], 1),
(params[2], x), (params[3], y),
(params[4], z))
def mk_tuple(name):
param = Parameter(name, set_cmd=None, get_cmd=None)
def getter():
return {name: param.get()}
return param, getter, ParamTable([ParamSpec(name, "numeric")])
def test_scan1D_no_gates(self):
p = Parameter('p', set_cmd=None)
r = VoltageDivider(p, 4)
scanjob = scanjob_t({'sweepdata': {'param': p, 'start': 0, 'end': 10, 'step': 2}, 'minstrument': [r]})
station=qcodes.Station()
dataset = scan1D(station, scanjob, liveplotwindow=False, verbose=0)
default_record_label = 'scan1D'
self.assertTrue(default_record_label in dataset.location)
def test_unmask_parameter(self):
p1 = Parameter("masking_param1", set_cmd=None, initial_value=1)
p2 = Parameter("masking_param2", set_cmd=None, initial_value=1)
with Measurement("mask_parameter") as msmt:
msmt.mask(p1, 2)
msmt.mask(p2, 3)
self.assertEqual(p1(), 2)
self.assertEqual(p2(), 3)
msmt.unmask(p2)
self.assertEqual(p1(), 2)
self.assertEqual(p2(), 1)
self.assertEqual(p1(), 1)
self.assertEqual(p2(), 1)
def test_unmask_parameter_attr(self):
p = Parameter("masking_param", set_cmd=None, initial_value=1)
p.x = 1
with Measurement("mask_parameter") as msmt:
msmt.mask(p, 2)
msmt.mask(p, x=3)
self.assertEqual(p(), 2)
self.assertEqual(p.x, 3)
msmt.unmask(p, attr="x")
self.assertEqual(p(), 2)
self.assertEqual(p.x, 1)
self.assertEqual(p(), 1)
self.assertEqual(p.x, 1)
def test_nested_function(self):
arrs = {}
p_sweep = Parameter("sweep", set_cmd=None)
with Measurement("measure_node") as msmt:
for k, val in enumerate(Sweep(p_sweep.sweep(0, 1, 0.1))):
results = {"result1": np.random.rand(), "result2": np.random.rand()}
msmt.measure(partial(self.nested_function, results))
# Save results to verification arrays
for kk, result in enumerate(results.values()):
arrs.setdefault((0, 0, kk), np.zeros(msmt.loop_shape))
arrs[(0, 0, kk)][k] = result
self.assertEqual(msmt.data_groups[(0, 0)].name, "nested_function_name")
verify_msmt(msmt, arrs)
