def test_initialize_parameters_from_list(self): par1 = Parameter("test") par1.value = 8 par2 = Parameter("test2", unit="meV") parameters = CalculatorParameters([par1, par2]) self.assertEqual(parameters["test"].value, 8)
def test_add_interval_after_value(self): par = Parameter("test") par.value = 4.0 par.add_interval(3, 4.5, True) par.clear_intervals() par.value = 5.0 with self.assertRaises(ValueError): par.add_interval(3, 4.5, True)
def test_clear_intervals(self): # FIXME par = Parameter("test") par.add_interval(3, 4.5, True) # self.assertEqual(par.__intervals, [[3, 4.5]]) #FIXME par.clear_intervals() par.add_option(9.7, True) # self.assertEqual(par.__options, [9.7]) par.clear_options()
def test_parameter_illegal_interval_plus_legal_option(self): par = Parameter("test") par.add_interval(None, 8.5, False) # minus infinite to 8.5 par.add_option(5, True) self.assertFalse(par.is_legal(-831.0)) self.assertFalse(par.is_legal(8.5)) self.assertTrue(par.is_legal(5.0)) self.assertTrue(par.is_legal(10.0)) self.assertTrue(par.is_legal(11.0))
def test_values_different_units(self): par = Parameter("energy", unit="meV", comment="Energy of emitted particles") import pint ureg = pint.UnitRegistry() with pytest.raises(pint.errors.DimensionalityError): thisunit = Unit("meter") par.value = 5 * thisunit
def test_parameter_iterable(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.add_option(7, True) self.assertFalse(par.is_legal([0.5, 3.2, 5.0])) self.assertTrue(par.is_legal([3.1, 4.2, 4.4])) self.assertTrue(par.is_legal([3.1, 4.2, 4.4, 7]))
def test_units_assignment(self): par = Parameter("test", unit="kg") assert par.unit == Unit("kg") par.unit = "cm" assert par.unit == Unit("cm") par.unit = "meter" assert par.unit == Unit("m") assert par.unit == str(Unit("m")) assert par.unit == "meter" par.unit = "nounit" assert par.unit == "nounit"
def test_parameter_legal_option_string(self): par = Parameter("test") par.add_option(["B", "A"], True) self.assertFalse(par.is_legal(10)) self.assertFalse(par.is_legal(9.8)) self.assertFalse(par.is_legal(True)) self.assertTrue(par.is_legal("A")) self.assertTrue(par.is_legal("B")) self.assertFalse(par.is_legal("C")) self.assertFalse(par.is_legal(38))
def test_parameter_no_legal_conditions(self): par = Parameter("test") self.assertTrue( par.is_legal(None)) # FIXME how is this supposed to work? self.assertTrue(par.is_legal(-999)) self.assertTrue(par.is_legal(-1)) self.assertTrue(par.is_legal(0)) self.assertTrue(par.is_legal(1)) self.assertTrue(par.is_legal("This is a string")) self.assertTrue(par.is_legal(True)) self.assertTrue(par.is_legal(False)) self.assertTrue(par.is_legal([0, "A", True]))
def test_parameter_legal_option_bool(self): par = Parameter("test") par.add_option(True, True) self.assertFalse(par.is_legal(10)) self.assertFalse(par.is_legal(9.8)) self.assertTrue(par.is_legal(True)) self.assertFalse(par.is_legal("A")) self.assertFalse(par.is_legal(38))
def test_parameter_get_options(self): """ Ensure get_options returns the options as required """ par = Parameter("test") par.add_interval(None, 8.5, False) # minus infinite to 8.5 par.add_option( 5, True) # this is stupid, already accounted in the interval par.add_option(11, True) retrieved_options = par.get_options() self.assertEqual(len(retrieved_options), 2) self.assertEqual(retrieved_options[0], 5.0) self.assertEqual(retrieved_options[1], 11.0) self.assertTrue(par.get_options_are_legal())
def test_parameters_with_quantity_powers(self): """Test if we can construct and use a Parameter instance passing pint.Quantity and pint.Unit objects to the constructor and interval setter. Use different powers of 10 in parameter initialization and value assignment.""" # Define the base unit of my parameter object. meter = Unit("meter") centimeter = Unit("centimeter") self.assertIsInstance(meter, Unit) minimum_undulator_length = 10.0 * meter undulator_length = Parameter("undulator_length", centimeter) self.assertIsInstance(undulator_length, Parameter) self.assertEqual(undulator_length.unit, Unit("centimeter")) undulator_length.add_interval( min_value=minimum_undulator_length, max_value=numpy.inf * meter, intervals_are_legal=True, ) print(undulator_length) self.assertTrue(undulator_length.is_legal(10.1 * meter)) self.assertFalse(undulator_length.is_legal(9.0 * centimeter)) self.assertTrue(undulator_length.is_legal(5.5e4 * Unit("centimeter")))
def test_parameter_multiple_options(self): par = Parameter("test") par.add_option(9.8, True) self.assertRaises(ValueError, par.add_option, 3, False) self.assertFalse(par.is_legal(-831.0)) self.assertTrue(par.is_legal(9.8)) self.assertFalse(par.is_legal(3))
def test_parameter_multiple_intervals(self): par = Parameter("test") par.add_interval(None, 8.5, True) # minus infinite to 8.5 self.assertRaises(ValueError, par.add_interval, 3, 4.5, False) self.assertTrue(par.is_legal(-831.0)) self.assertTrue(par.is_legal(3.5)) self.assertTrue(par.is_legal(5.0)) self.assertFalse(par.is_legal(10.0))
def test_get_intervals(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.add_interval(8, 10, True) retrived_intervals = par.get_intervals() self.assertEqual(len(retrived_intervals), 2) self.assertEqual(retrived_intervals[0][0], 3) self.assertEqual(retrived_intervals[0][1], 4.5) self.assertEqual(retrived_intervals[1][0], 8) self.assertEqual(retrived_intervals[1][1], 10) self.assertTrue(par.get_intervals_are_legal())
def test_parameter_from_dict(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.value = 4.0 par_from_dict = Parameter.from_dict(par.__dict__) self.assertEqual(par_from_dict.value, 4.0)
def test_get_item(self): par1 = Parameter("test") par1.value = 8 par2 = Parameter("test2", unit="meV") par2.value = 10 parameters = CalculatorParameters() self.assertRaises(KeyError, parameters.__getitem__, "test3")
def test_print_parameters(self): par1 = Parameter("test") par1.value = 8 par2 = Parameter("test2", unit="meV") par2.value = 10 parameters = CalculatorParameters() parameters.add(par1) parameters.add(par2) print(parameters)
def test_parameter_set_value(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.value = 4.0 self.assertEqual(par.value, 4.0) with self.assertRaises(ValueError): par.value = 5.0 # Should throw an error and be ignored self.assertEqual(par.value, 4.0)
def test_initialize_parameters_from_add(self): par1 = Parameter("test") par1.value = 8 par2 = Parameter("test2", unit="meV") par2.value = 10 parameters = CalculatorParameters() parameters.add(par1) parameters.add(par2) self.assertEqual(parameters["test"].value, 8) self.assertEqual(parameters["test2"].value, 10)
def test_json_with_objects(self): par1 = Parameter("test") par1.value = 8 par2 = Parameter("test2", unit="meV") par2.value = 10 par3 = Parameter("test3", unit="meV") par3.value = 3.14 parameters = CalculatorParameters() parameters.add(par1) parameters.add(par2) parameters.add(par3) with tempfile.TemporaryDirectory() as d: tmp_file = os.path.join(d, "test.json") tmp_file = "/tmp/test.json" parameters.to_json(tmp_file) params_json = CalculatorParameters.from_json(tmp_file) self.assertEqual(params_json["test2"].value, 10) print(params_json["test3"]) assert params_json["test3"].value == par3.value assert params_json["test3"].value == 3.14 assert params_json["test3"].value_no_conversion == Quantity( 3.14, "meV")
def test_json(self): par1 = Parameter("test") par1.value = 8.0 par2 = Parameter("test2", unit="meV") par2.value = 10 parameters = CalculatorParameters() parameters.add(par1) parameters.add(par2) with tempfile.TemporaryDirectory() as d: tmp_file = os.path.join(d, "test.json") parameters.to_json(tmp_file) params_json = CalculatorParameters.from_json(tmp_file) self.assertEqual(params_json["test2"].value, 10) assert params_json["test2"].value_no_conversion == Quantity( 10, "meV") with pytest.raises(TypeError): params_json["test2"].value = "A"
def test_parameter_legal_interval(self): par = Parameter("test") par.add_interval(3, 4.5, True) self.assertTrue(par.is_legal(3.5)) self.assertFalse(par.is_legal(1.0))
def test_parameter_legal_option_fromlist(self): par = Parameter("test") par.add_option([9, 8, 38], True) self.assertFalse(par.is_legal(10)) self.assertFalse(par.is_legal(9.8)) self.assertFalse(par.is_legal(True)) self.assertFalse(par.is_legal("A")) self.assertTrue(par.is_legal(38)) self.assertTrue(par.is_legal(38.0)) self.assertTrue(par.is_legal(8))
def test_parameter_illegal_interval_plus_illegal_option(self): par = Parameter("test") par.add_interval(None, 8.5, False) # minus infinite to 8.5 par.add_option( 5, False) # this is stupid, already accounted in the interval par.add_option(11, False) self.assertFalse(par.is_legal(-831.0)) self.assertFalse(par.is_legal(8.5)) # illegal because closed interval self.assertFalse(par.is_legal(5.0)) self.assertTrue(par.is_legal(10.0)) self.assertFalse(par.is_legal(11.0))
def test_parameter_value_type(self): par = Parameter("test") par.value = 4.0 assert par._Parameter__value_type == Quantity par1 = Parameter("test") par1.value = 4 assert par1._Parameter__value_type == int par2 = Parameter("test", unit="meV") par2.value = 4 assert par2._Parameter__value_type == Quantity par3 = Parameter("test", unit="meV") par3.add_interval(0, 1e6, True) assert par3._Parameter__value_type == Quantity
def test_parameter_set_numpy_value(self): par = Parameter("test", unit="eV") par.value = 1e-4 par.value = numpy.log(10)
def test_print(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.add_option(9.8, True) print(par)
def test_check_value_type(self): par = Parameter("test") v = 1 par._Parameter__check_compatibility(v) par._Parameter__set_value_type(v) assert par._Parameter__value_type == int v = 1.0 par._Parameter__check_compatibility(v) par._Parameter__set_value_type(v) assert par._Parameter__value_type == Quantity v = "string" with pytest.raises(TypeError): par._Parameter__check_compatibility(v) par._Parameter__set_value_type(v) assert par._Parameter__value_type == str v = True par = Parameter("test") par._Parameter__set_value_type("string") assert par._Parameter__value_type == str with pytest.raises(TypeError): par._Parameter__check_compatibility(v) par = Parameter("test") par._Parameter__set_value_type(True) assert par._Parameter__value_type == bool v = ["ciao", True] par = Parameter("test") with pytest.raises(TypeError): par._Parameter__check_compatibility(v) par._Parameter__set_value_type([False, True]) v = {"ciao": True, "bye": "string"} par = Parameter("test") with pytest.raises(NotImplementedError): par._Parameter__check_compatibility(v) v = {"ciao": True, "bye": False} with pytest.raises(NotImplementedError): par._Parameter__check_compatibility(v) v = numpy.random.uniform(0, 1, 10) par = Parameter("test") par._Parameter__check_compatibility(v) par._Parameter__set_value_type(v) assert par._Parameter__value_type == Quantity
def test_print_legal_interval(self): par = Parameter("test") par.add_interval(3, 4.5, True) par.add_option(9.8, True) par.print_parameter_constraints()