def test_validation_one_sp_dim_missing(): """ If one or more setpoint validators has no shape the validation will fail. """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) setpoints_1 = Parameter( "setpoints_1", get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, None)), ) param_sp_without_shape = ParameterWithSetpoints( "param_6", get_cmd=lambda: rand(n_points_1()), setpoints=(setpoints_1, ), vals=vals.Arrays(shape=(n_points_1, n_points_2)), ) expected_err_msg = ( r"One or more dimensions have unknown shape " r"when comparing output: \(<qcodes.parameters.parameter.Parameter: n_points_1 at [0-9]+>, <qcodes.parameters.parameter.Parameter: n_points_2 at [0-9]+>\) to setpoints: " r"\(<qcodes.parameters.parameter.Parameter: n_points_1 at [0-9]+>, None\)" ) with pytest.raises(ValueError, match=expected_err_msg): param_sp_without_shape.validate_consistent_shape() with pytest.raises(ValueError, match=expected_err_msg): param_sp_without_shape.validate(param_sp_without_shape.get())
def test_stepping_from_invalid_starting_point(): the_value = -10 def set_function(value): nonlocal the_value the_value = value def get_function(): return the_value a = Parameter('test', set_cmd=set_function, get_cmd=get_function, vals=Numbers(0, 100), step=5) # We start out by setting the parameter to an # invalid value. This is not possible using initial_value # as the validator will catch that but perhaps this may happen # if the instrument can return out of range values. assert a.get() == -10 with pytest.raises(ValueError): # trying to set to 10 should raise even with 10 valid # as the steps demand that we first step to -5 which is not a.set(10) # afterwards the value should still be the same assert a.get() == -10
def test_setpoints_non_parameter_raises(): """ Test that putting some random function as a setpoint parameter will raise as expected. """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) err_msg = (r"Setpoints is of type <class 'function'> " r"expcected a QCoDeS parameter") with pytest.raises(TypeError, match=err_msg): param_with_setpoints_1 = ParameterWithSetpoints( 'param_1', get_cmd=lambda: rand(n_points_1()), setpoints=(lambda x: x, ), vals=vals.Arrays(shape=(n_points_1, ))) param_with_setpoints_1 = ParameterWithSetpoints( 'param_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) with pytest.raises(TypeError, match=err_msg): param_with_setpoints_1.setpoints = (lambda x: x, )
def test_setting_non_gettable_parameter_with_finite_step(caplog): initial_value = 0 step_size = 0.1 set_value = 1.0 # when the parameter is initially set from # the initial_value the starting point is unknown # so this should cause a warning but the parameter should still be set with caplog.at_level(logging.WARNING): x = Parameter('x', initial_value=initial_value, step=step_size, set_cmd=None) assert len(caplog.records) == 1 assert f"cannot sweep x from None to {initial_value}" in str( caplog.records[0]) assert x.cache.get() == 0 # afterwards the stepping should work as expected. with caplog.at_level(logging.WARNING): caplog.clear() assert_array_almost_equal( np.array(x.get_ramp_values(set_value, step_size)), (np.arange( initial_value + step_size, set_value + step_size, step_size))) x.set(set_value) assert x.cache.get() == set_value assert len(caplog.records) == 0
def test_validation_wrong_validator(): """ If the validator does not match the actual content the validation should fail """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) # output is not consistent with validator param_with_wrong_validator = ParameterWithSetpoints( 'param_2', get_cmd=lambda: rand(n_points_2()), setpoints=(setpoints_1, ), vals=vals.Arrays(shape=(n_points_1, ))) # this does not raise because the validator shapes are consistent param_with_wrong_validator.validate_consistent_shape() # but the output is not consistent with the validator with pytest.raises(ValueError, match=r'does not have expected shape' r' \(10,\), ' r'it has shape \(20,\); ' r'Parameter: param_2'): param_with_wrong_validator.validate(param_with_wrong_validator())
def test_validation_inconsistent_shape(): """ Parameters with shapes inconsistent with their setpoints should not validate """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) param_with_diff_length = ParameterWithSetpoints( 'param_1', get_cmd=lambda: rand(n_points_2()), setpoints=(setpoints_1, ), vals=vals.Arrays(shape=(n_points_2, ))) # inconsistent shapes expected_err_msg = ( r"Shape of output is not consistent " r"with setpoints. Output is shape " r"\(<qcodes.parameters.parameter.Parameter: n_points_2 at [0-9]+>,\) " r"and setpoints are shape " r"\(<qcodes.parameters.parameter.Parameter: n_points_1 at [0-9]+>,\)") with pytest.raises(ValueError, match=expected_err_msg): param_with_diff_length.validate_consistent_shape() with pytest.raises(ValueError, match=expected_err_msg): param_with_diff_length.validate(param_with_diff_length.get())
def test_set_on_parameter_marked_as_non_settable_raises(): a = Parameter("param", set_cmd=None) a.set(2) assert a.get() == 2 a._settable = False with pytest.raises( TypeError, match="Trying to set a parameter that is not settable."): a.set(1) assert a.get() == 2
def test_number_of_validations(): p = Parameter('p', set_cmd=None, initial_value=0, vals=BookkeepingValidator()) # in the set wrapper the final value is validated # and then subsequently each step is validated. # in this case there is one step so the final value # is validated twice. assert p.vals.values_validated == [0, 0] p.step = 1 p.set(10) assert p.vals.values_validated == [0, 0, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def array_in_str_dataset(experiment, request): meas = Measurement() scalar_param = Parameter('textparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param, paramtype='text') meas.register_parameter(param, setpoints=(scalar_param, ), paramtype=request.param) with meas.run() as datasaver: for i in ['A', 'B', 'C']: scalar_param.set(i) datasaver.add_result((scalar_param, scalar_param.get()), (param, param.get())) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def array_in_scalar_dataset(experiment): meas = Measurement() scalar_param = Parameter('scalarparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param) meas.register_parameter(param, setpoints=(scalar_param, ), paramtype='array') with meas.run() as datasaver: for i in range(1, 10): scalar_param.set(i) datasaver.add_result((scalar_param, scalar_param.get()), (param, param.get())) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def test_validation_without_shape(): """ If the Arrays validator does not have a shape the validation will fail """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) with pytest.raises(RuntimeError, match=r"A ParameterWithSetpoints must " r"have a shape defined " r"for its validator."): param_without_shape = ParameterWithSetpoints( 'param_5', get_cmd=lambda: rand(n_points_1()), setpoints=(setpoints_1, ), vals=vals.Arrays())
def test_validation_no_validator(): """ If a parameter does not use array validators it cannot be validated. """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) # output does not have a validator with pytest.raises(ValueError, match=r"A ParameterWithSetpoints must have " r"an Arrays validator got " r"<class 'NoneType'>"): param_without_validator = ParameterWithSetpoints( 'param_3', get_cmd=lambda: rand(n_points_1()), setpoints=(setpoints_1, ))
def test_validation_shapes(): """ Test that various parameters with setpoints and shape combinations validate correctly. """ n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: rand(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) setpoints_2 = Parameter('setpoints_2', get_cmd=lambda: rand(n_points_2()), vals=vals.Arrays(shape=(n_points_2, ))) param_with_setpoints_1 = ParameterWithSetpoints( "param_1", get_cmd=lambda: rand(n_points_1()), setpoints=(setpoints_1, ), vals=vals.Arrays(shape=(n_points_1, )), ) assert ("<Arrays, shape: (<qcodes.parameters.parameter." "Parameter: n_points_1 at" in param_with_setpoints_1.__doc__) # the two shapes are the same so validation works param_with_setpoints_1.validate_consistent_shape() param_with_setpoints_1.validate(param_with_setpoints_1.get()) param_with_setpoints_2 = ParameterWithSetpoints( 'param_2', get_cmd=lambda: rand(n_points_1(), n_points_2()), vals=vals.Arrays(shape=(n_points_1, n_points_2))) param_with_setpoints_2.setpoints = (setpoints_1, setpoints_2) # 2d param_with_setpoints_2.validate_consistent_shape() param_with_setpoints_2.validate(param_with_setpoints_2.get())
def test_get_cache(): time_resolution = time.get_clock_info('time').resolution sleep_delta = 2 * time_resolution # Create a gettable parameter local_parameter = Parameter('test_param', set_cmd=None, get_cmd=None) before_set = datetime.now() time.sleep(sleep_delta) local_parameter.set(1) time.sleep(sleep_delta) after_set = datetime.now() # Check we return last set value, with the correct timestamp assert local_parameter.cache.get() == 1 assert before_set < local_parameter.cache.timestamp < after_set # Check that updating the value updates the timestamp time.sleep(sleep_delta) local_parameter.set(2) assert local_parameter.cache.get() == 2 assert local_parameter.cache.timestamp > after_set
class TestMeasure(TestCase): def setUp(self): self.p1 = Parameter('P1', initial_value=1, get_cmd=None, set_cmd=None) def test_simple_scalar(self): data = Measure(self.p1).run_temp() self.assertEqual(data.single_set.tolist(), [0]) self.assertEqual(data.P1.tolist(), [1]) self.assertEqual(len(data.arrays), 2, data.arrays) self.assertNotIn('loop', data.metadata) meta = data.metadata['measurement'] self.assertEqual(meta['__class__'], 'qcodes.measure.Measure') self.assertEqual(len(meta['actions']), 1) self.assertFalse(meta['use_threads']) ts_start = datetime.strptime(meta['ts_start'], '%Y-%m-%d %H:%M:%S') ts_end = datetime.strptime(meta['ts_end'], '%Y-%m-%d %H:%M:%S') self.assertGreaterEqual(ts_end, ts_start) def test_simple_array(self): data = Measure(MultiGetter(arr=(1.2, 3.4))).run_temp() self.assertEqual(data.index0_set.tolist(), [0, 1]) self.assertEqual(data.arr.tolist(), [1.2, 3.4]) self.assertEqual(len(data.arrays), 2, data.arrays) def test_array_and_scalar(self): self.p1.set(42) data = Measure(MultiGetter(arr=(5, 6)), self.p1).run_temp() self.assertEqual(data.single_set.tolist(), [0]) self.assertEqual(data.P1.tolist(), [42]) self.assertEqual(data.index0_set.tolist(), [0, 1]) self.assertEqual(data.arr.tolist(), [5, 6]) self.assertEqual(len(data.arrays), 4, data.arrays)
def test_validation_sp_no_validator(): """ If the setpoints do not have an Arrays validator validation will fail. """ n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_2.set(20) # setpoints do not have a validator setpoints_2 = Parameter('setpoints_2', get_cmd=lambda: rand(n_points_2())) param_sp_without_validator = ParameterWithSetpoints( 'param_4', get_cmd=lambda: rand(n_points_2()), setpoints=(setpoints_2, ), vals=vals.Arrays(shape=(n_points_2, ))) expected_err_msg = (r"Can only validate shapes for " r"parameters with Arrays validator. " r"setpoints_2 is a setpoint") with pytest.raises(ValueError, match=expected_err_msg): param_sp_without_validator.validate_consistent_shape() with pytest.raises(ValueError, match=expected_err_msg): param_sp_without_validator.validate(param_sp_without_validator.get())
def test_get_cache_no_get(): """ Test that cache.get on a parameter that does not have get is handled correctly. """ local_parameter = Parameter('test_param', set_cmd=None, get_cmd=False) # The parameter does not have a get method. with pytest.raises(AttributeError): local_parameter.get() # get_latest will fail as get cannot be called and no cache # is available with pytest.raises(RuntimeError): local_parameter.cache.get() value = 1 local_parameter.set(value) assert local_parameter.cache.get() == value local_parameter2 = Parameter('test_param2', set_cmd=None, get_cmd=False, initial_value=value) with pytest.raises(AttributeError): local_parameter2.get() assert local_parameter2.cache.get() == value
def array_in_scalar_dataset_unrolled(experiment): """ This fixture yields a dataset where an array-valued parameter is registered as a 'numeric' type and has an additional single-valued setpoint. We expect data to be saved as individual scalars, with the scalar setpoint repeated. """ meas = Measurement() scalar_param = Parameter('scalarparam', set_cmd=None) param = ArraySetPointParam() meas.register_parameter(scalar_param) meas.register_parameter(param, setpoints=(scalar_param, ), paramtype='numeric') with meas.run() as datasaver: for i in range(1, 10): scalar_param.set(i) datasaver.add_result((scalar_param, scalar_param.get()), (param, param.get())) try: yield datasaver.dataset finally: datasaver.dataset.conn.close()
def parameters(): n_points_1 = Parameter('n_points_1', set_cmd=None, vals=vals.Ints()) n_points_2 = Parameter('n_points_2', set_cmd=None, vals=vals.Ints()) n_points_3 = Parameter('n_points_3', set_cmd=None, vals=vals.Ints()) n_points_1.set(10) n_points_2.set(20) n_points_3.set(15) setpoints_1 = Parameter('setpoints_1', get_cmd=lambda: np.arange(n_points_1()), vals=vals.Arrays(shape=(n_points_1, ))) setpoints_2 = Parameter('setpoints_2', get_cmd=lambda: np.arange(n_points_2()), vals=vals.Arrays(shape=(n_points_2, ))) setpoints_3 = Parameter('setpoints_3', get_cmd=lambda: np.arange(n_points_3()), vals=vals.Arrays(shape=(n_points_3, ))) yield (n_points_1, n_points_2, n_points_3, setpoints_1, setpoints_2, setpoints_3)