def test6(self): print("Test 5: testing mixed nbody and string units") nbody_parameter_definition = parameters.ModuleMethodParameterDefinition( "get_nbody", None, "nbody_par_name", "a test parameter with nbody units", 11.0 | nbody_system.length) string_parameter_definition = parameters.ModuleMethodParameterDefinition( "get_string", None, "string_par_name", "a test parameter with string units", "test string") class TestModule(BaseTestModule): x = 123.0 | nbody_system.length def get_nbody(self): return self.x def get_string(self): return str(10 * self.x.number) o = TestModule() x = parameters.Parameters( [string_parameter_definition, nbody_parameter_definition], o) self.assertTrue("nbody_par_name" in str(x)) self.assertTrue("123.0 length" in str(x)) self.assertTrue("string_par_name" in str(x)) self.assertTrue("1230.0" in str(x)) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.ParametersWithUnitsConverted( x, convert_nbody.as_converter_from_si_to_generic()) self.assertEqual(getattr(y, "string_par_name"), "1230.0") self.assertAlmostEqual(getattr(y, "nbody_par_name"), 246.0 | units.m)
def test5(self): print "Test 5: testing mixed nbody and physical units" phys_parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "phys_test_name", "a test parameter with physical units", 11.0 | units.m ) nbody_parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test1", "set_test1", "nbody_test_name", "a test parameter with nbody units", 11.0 | nbody_system.length ) class TestModule(BaseTestModule): x = 123.0 | units.m y = 123.0 | nbody_system.length def get_test(self): return self.x def set_test(self, value): self.x = value def get_test1(self): return self.y def set_test1(self, value): self.y = value o = TestModule() x = parameters.Parameters([phys_parameter_definition, nbody_parameter_definition], o) self.assertTrue("nbody_test_name" in str(x)) self.assertTrue("123.0 length" in str(x)) self.assertTrue("phys_test_name" in str(x)) self.assertTrue("123.0 m" in str(x)) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.ParametersWithUnitsConverted( x, convert_nbody.as_converter_from_si_to_generic() ) self.assertEquals(getattr(y,"phys_test_name"), 123.0 | units.m) self.assertAlmostEquals(getattr(y,"nbody_test_name"), 246.0 | units.m) y.phys_test_name = 1234.0 | units.m self.assertEquals(y.phys_test_name, 1234.0 | units.m) y.nbody_test_name = 12345.0 | nbody_system.length self.assertAlmostEquals(y.nbody_test_name, 24690.0 | units.m) y.nbody_test_name = 12345.0 | units.m self.assertEquals(y.nbody_test_name, 12345.0 | units.m)
def test3b(self): # Same test as test3, but testing on the class, not instance # This makes sure the python 'help' functionality works on parameters parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", None, "test_name", "a test parameter", 11.0 | nbody_system.length) class TestModule(BaseTestModule): x = 123 | units.m def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() x = parameters.new_parameters_instance_with_docs( [parameter_definition], o) self.assertTrue("test_name" in x.__class__.__doc__) self.assertTrue("a test parameter" in x.__class__.__doc__) self.assertTrue("default" in x.__class__.__doc__) self.assertTrue("11.0 length" in x.__class__.__doc__) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.new_parameters_with_units_converted_instance_with_docs( x, convert_nbody.as_converter_from_si_to_generic()) self.assertTrue("test_name" in y.__class__.__doc__) self.assertTrue("a test parameter" in y.__class__.__doc__) self.assertTrue("default" in y.__class__.__doc__) self.assertTrue("22.0 m" in y.__class__.__doc__)
def test2(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | nbody_system.length) class TestModule(BaseTestModule): x = 123 | nbody_system.length def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() x = parameters.Parameters([parameter_definition], o) self.assertEqual(x.test_name, 123 | nbody_system.length) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.ParametersWithUnitsConverted( x, convert_nbody.as_converter_from_si_to_generic()) self.assertAlmostEqual(y.test_name.value_in(units.m), 246.0, 6) y.test_name = 500 | units.m self.assertAlmostEqual(y.test_name.value_in(units.m), 500.0, 6) print(x.test_name, o.x) self.assertAlmostEqual(x.test_name.value_in(nbody_system.length), 250.0, 6) self.assertAlmostEqual(o.x, 250.0 | nbody_system.length, 6)
def test9(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value instance = TestModule() p = parameters.Parameters([parameter_definition], instance) self.assertRaises(AmuseException, lambda: p.unknown, expected_message = "tried to get unknown parameter 'unknown' for a 'TestModule' object") with warnings.catch_warnings(record=True) as w: p.unknown = 10 | units.m self.assertEquals(len(w), 1) self.assertEquals("tried to set unknown parameter 'unknown' for a 'TestModule' object", str(w[-1].message))
def test12(self): definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 0.1 | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() set = parameters.Parameters([definition,], o) set.test_name = 10|units.m self.assertEqual(o.x, 10|units.m) self.assertEqual(set.test_name, 10|units.m) memento = set.copy() self.assertEqual(memento.test_name, 10|units.m) set.test_name = 20|units.m self.assertEqual(o.x, 20|units.m) self.assertEqual(set.test_name, 20|units.m) self.assertEqual(memento.test_name, 10|units.m) set.reset_from_memento(memento) self.assertEqual(o.x, 10|units.m) self.assertEqual(set.test_name, 10|units.m) self.assertEqual(memento.test_name, 10|units.m)
def test4(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 0.1 | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value class TestModuleBinding(object): parameter_definitions = [parameter_definition] def __init__(self): self.parameters = parameters.Parameters(self.parameter_definitions, self) class TestInterface(TestModule, TestModuleBinding): def __init__(self): TestModuleBinding.__init__(self) instance = TestInterface() self.assertTrue('test_name' in list(instance.parameters.names())) instance.parameters.test_name = 1 | units.km self.assertEquals(1 | units.km, instance.parameters.test_name) self.assertEquals(1000 | units.m, instance.x)
def test4(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", None, "test_name", "a test parameter", 11.0 | nbody_system.length ) class TestModule(BaseTestModule): x = 123.0 | nbody_system.length def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() x = parameters.Parameters([parameter_definition], o) self.assertTrue("test_name" in str(x)) self.assertTrue("123.0 length" in str(x)) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.ParametersWithUnitsConverted( x, convert_nbody.as_converter_from_si_to_generic() ) self.assertTrue("test_name" in str(y)) self.assertTrue("246.0 m" in str(y))
def test3(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", None, "test_name", "a test parameter", 11.0 | nbody_system.length ) class TestModule(BaseTestModule): x = 123 | units.m def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() x = parameters.new_parameters_instance_with_docs([parameter_definition], o) self.assertTrue("test_name" in x.__doc__) self.assertTrue("a test parameter" in x.__doc__) self.assertTrue("default" in x.__doc__) self.assertTrue("11.0 length" in x.__doc__) convert_nbody = nbody_system.nbody_to_si(2.0 | units.m, 4.0 | units.kg) y = parameters.new_parameters_with_units_converted_instance_with_docs( x, convert_nbody.as_converter_from_si_to_generic() ) self.assertTrue("test_name" in y.__doc__) self.assertTrue("a test parameter" in y.__doc__) self.assertTrue("default" in y.__doc__) self.assertTrue("22.0 m" in y.__doc__)
def test9(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value instance = TestModule() p = parameters.Parameters([parameter_definition], instance) self.assertRaises( AmuseException, lambda: p.unknown, expected_message= "tried to get unknown parameter 'unknown' for a 'TestModule' object" ) self.assertRaises( AmuseException, setattr, p, "unknown", 1.0 | units.m, expected_message= "tried to set unknown parameter 'unknown' for a 'TestModule' object" )
def test1(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m ) class TestModule(BaseTestModule): x = 123 | units.m def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() x = parameters.Parameters([parameter_definition], o) value = x.test_name self.assertTrue(value.unit.has_same_base_as(units.m)) self.assertEqual(value.value_in(units.m), 123)
def test10(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", None, "test_name", "a test parameter", 11.0 | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value instance = TestModule() p = parameters.Parameters([parameter_definition], instance) instance.x = 1 | units.m self.assertEquals(p.test_name, 1 | units.m) def try_set_read_only_parameter(parameter_set): parameter_set.test_name = 2 | units.m self.assertRaises(AmuseException, try_set_read_only_parameter, p, expected_message = "Could not set value for parameter 'test_name' of a 'TestModule' object, parameter is read-only")
def test6(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", "bla" ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value class TestModuleBinding(object): parameter_definitions = [parameter_definition] def __init__(self): self.parameters = parameters.Parameters(self.parameter_definitions, self) class TestInterface(TestModule, TestModuleBinding): def __init__(self): TestModuleBinding.__init__(self) instance = TestInterface() instance.parameters.test_name = "bla" self.assertEquals("bla", instance.x) instance.parameters.test_name = "bla" self.assertEquals("bla", instance.x )
def test1(self): definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 0.1 | m) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() set = parameters.Parameters([ definition, ], o) set.test_name = 10 | m self.assertEqual(o.x, 10 | m) self.assertEqual(set.test_name, 10 | m) memento = set.copy() self.assertEqual(memento.test_name, 10 | m) pickled_memento = pickle.dumps(memento) unpickled_memento = pickle.loads(pickled_memento) self.assertEqual(memento.test_name, unpickled_memento.test_name)
def test9(self): parameter_definition1 = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m ) parameter_definition2 = parameters.ModuleMethodParameterDefinition( "get_test1", "set_test1", "test_name2", "a test parameter", 12.0 | units.m ) paramer_definition3 = parameters.VectorParameterDefinition( "test_vector", "vector of parameters", ["test_name", "test_name2"], [11.0, 12.0] | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value def get_test1(self): return self.y def set_test1(self, value): self.y = value instance = TestModule() instance.x = 1 | units.m instance.y = 2 | units.m p = parameters.Parameters([parameter_definition1, parameter_definition2, paramer_definition3], instance) self.assertEquals(p.test_vector, (1,2) | units.m) p.test_vector = (3,4) | units.m self.assertEquals(instance.x, 3 | units.m) self.assertEquals(instance.y, 4 | units.m)
def test11(self): parameter_definition1 = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m ) parameter_definition2 = parameters.ModuleMethodParameterDefinition( "get_test1", "set_test1", "test_name2", "a test parameter", 12.0 | units.m ) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value def get_test1(self): return self.y def set_test1(self, value): self.y = value instance = TestModule() p = parameters.Parameters([parameter_definition1, parameter_definition2], instance) instance.x = 1 | units.m instance.y = 2 | units.m self.assertEquals(p.test_name, 1 | units.m) self.assertEquals(p.test_name2, 2 | units.m) p.test_name = 20 | units.m p.send_not_set_parameters_to_code() self.assertEquals(instance.x, 20 | units.m) self.assertEquals(instance.y, 12 | units.m)
def test10(self): print("Testing ParametersWithUnitsConverted on vector parameters") definitions = [] for par_name in ["length_x", "length_y", "length_z"]: definitions.append( parameters.ModuleMethodParameterDefinition( "get_" + par_name, "set_" + par_name, par_name, "a test parameter", 10.0 | generic_unit_system.length)) definitions.append( parameters.VectorParameterDefinition( "mesh_length", "length of the model in the x, y and z directions", ("length_x", "length_y", "length_z"), [10, 10, 10] | generic_unit_system.length)) class TestModule(BaseTestModule): x = 123.0 | generic_unit_system.length y = 456.0 | generic_unit_system.length z = 789.0 | generic_unit_system.length def get_length_x(self): return self.x def set_length_x(self, value): self.x = value def get_length_y(self): return self.y def set_length_y(self, value): self.y = value def get_length_z(self): return self.z def set_length_z(self, value): self.z = value o = TestModule() x = parameters.Parameters(definitions, o) self.assertTrue("mesh_length" in str(x)) self.assertTrue("[123.0, 456.0, 789.0] length" in str(x)) converter = generic_unit_converter.ConvertBetweenGenericAndSiUnits( 2.0 | units.m, 4.0 | units.kg, 6.0 | units.s) y = parameters.ParametersWithUnitsConverted( x, converter.as_converter_from_si_to_generic()) self.assertTrue("mesh_length" in str(y)) self.assertTrue("[246.0, 912.0, 1578.0] m" in str(y))
def test13(self): definition = parameters.ModuleMethodParameterDefinition( "get_test", None, "test_name", "a read-only test parameter", 0.1 | units.m) class TestModule(BaseTestModule): x = 0.1 | units.m def get_test(self): return self.x o = TestModule() set = parameters.Parameters([ definition, ], o) self.assertRaises( AmuseException, setattr, set, "test_name", 1.0 | units.m, expected_message= "Could not set value for parameter 'test_name' of a 'TestModule' object, parameter is read-only" ) self.assertEqual(o.x, 0.1 | units.m) self.assertEqual(set.test_name, 0.1 | units.m) memento = set.copy() self.assertEqual(memento.test_name, 0.1 | units.m) set.reset_from_memento(memento) self.assertEqual(o.x, 0.1 | units.m) self.assertEqual(set.test_name, 0.1 | units.m) memento.test_name = 2.0 | units.m self.assertEqual(memento.test_name, 2.0 | units.m) self.assertRaises( AmuseException, set.reset_from_memento, memento, expected_message= "tried to change read-only parameter 'test_name' for a 'TestModule' object" ) self.assertEqual(o.x, 0.1 | units.m) self.assertEqual(set.test_name, 0.1 | units.m) self.assertEqual(memento.test_name, 2.0 | units.m)
def test1(self): class TestModule(BaseTestModule): def get_test(self): return 123 | units.m o = TestModule() set = parameters.Parameters([ parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 0.1 | units.m) ], o) x = set.get_parameter("test_name") value = x.get_value() self.assertTrue(value.unit.has_same_base_as(units.m)) self.assertEqual(value.value_in(units.m), 123)
def test8(self): parameter_definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 11.0 | units.m) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value instance = TestModule() p = parameters.Parameters([parameter_definition], instance) p.set_defaults() self.assertEqual(11.0 | units.m, instance.x)
def test3(self): definition = parameters.ModuleMethodParameterDefinition( "get_test", "set_test", "test_name", "a test parameter", 0.1 | units.no_unit) class TestModule(BaseTestModule): def get_test(self): return self.x def set_test(self, value): self.x = value o = TestModule() set = parameters.Parameters([definition,], o) x = set.get_parameter("test_name") x.set_value(10|units.none) self.assertEqual(o.x, 10|units.none) value = x.get_value() self.assertEqual(value, 10)
def __init__(self, softening_mode="shared"): self.particles = Particles() if softening_mode == "individual": self.softening_mode = "individual" self._softening_lengths_squared = self._softening_lengths_squared_individual self._softening_lengths = self._softening_lengths_individual else: self.softening_mode = "shared" self._softening_lengths_squared = self._softening_lengths_squared_shared self._softening_lengths = self._softening_lengths_shared epsilon_squared_parameter = parameters.ModuleMethodParameterDefinition( "get_epsilon_squared", "set_epsilon_squared", "epsilon_squared", "gravitational softening length squared", default_value = 0.0 | nbody_system.length**2, must_set_before_get = False ) self.parameters = parameters.new_parameters_instance_with_docs([epsilon_squared_parameter], self) self.epsilon_squared = 0.0 | nbody_system.length**2