def test_recursively_validate_defaults(self):
# only parameters from defaults are validated, no new values are added
kp = Parameters(incomplete)
tmp = Parameters(defaults)
kp.RecursivelyValidateDefaults(tmp)
self.assertFalse(kp.Has("bool_value"))
self.assertFalse(kp.Has("double_value"))
self.assertTrue(kp.Has("level1"))
def test_remove_value(self):
kp = Parameters(json_string)
self.assertTrue(kp.Has("int_value"))
self.assertTrue(kp.Has("level1"))
kp.RemoveValue("int_value")
kp.RemoveValue("level1")
self.assertFalse(kp.Has("int_value"))
self.assertFalse(kp.Has("level1"))
def test_add_value(self):
kp = Parameters("{}")
kp.AddEmptyValue("new_double").SetDouble(1.0)
self.assertTrue(kp.Has("new_double"))
self.assertEqual(kp["new_double"].GetDouble(), 1.0)
class TestParameters(KratosUnittest.TestCase):
def setUp(self):
self.kp = Parameters(json_string)
self.compact_expected_output = """{"int_value":10,"double_value":2.0,"bool_value":true,"string_value":"hello","level1":{"list_value":[3,"hi",false],"tmp":5.0}}"""
if (sys.version_info < (3, 2)):
self.assertRaisesRegex = self.assertRaisesRegexp
def test_kratos_parameters(self):
self.assertEqual(self.kp.WriteJsonString(),
self.compact_expected_output)
self.assertTrue(self.kp.Has("int_value"))
self.assertFalse(self.kp.Has("unextisting_value"))
self.assertEqual(self.kp["int_value"].GetInt(), 10)
self.assertEqual(self.kp["double_value"].GetDouble(), 2.0)
self.assertEqual(self.kp["bool_value"].GetBool(), True)
self.assertEqual(self.kp["string_value"].GetString(), "hello")
self.assertEqual(self.kp.PrettyPrintJsonString(), pretty_out)
def test_kratos_change_parameters(self):
# now change one item in the sublist
subparams = self.kp["level1"]
my_list = subparams["list_value"]
for i in range(my_list.size()):
if my_list[i].IsBool():
self.assertEqual(my_list[i].GetBool(), False)
# my_list = subparams["list_value"]
subparams["list_value"][0].SetString("changed")
self.assertEqual(self.kp.PrettyPrintJsonString(),
pretty_out_after_change)
def test_kratos_copy_parameters(self):
# try to make a copy
original_out = self.kp.PrettyPrintJsonString()
other_copy = self.kp.Clone()
self.assertEqual(other_copy.PrettyPrintJsonString(), original_out)
other_copy["int_value"].SetInt(-1)
self.assertEqual(self.kp["int_value"].GetInt(), 10)
# self.assertEqual(other_copy["int_value").GetString(),-1)
def test_set_value(self):
kp = Parameters(json_string)
kp1 = Parameters(pretty_out_after_change)
kp["bool_value"] = kp1["level1"]
kp["bool_value"].PrettyPrintJsonString()
self.assertEqual(kp["bool_value"].PrettyPrintJsonString(),
kp1["level1"].PrettyPrintJsonString())
def test_kratos_wrong_parameters(self):
# should check which errors are thrown!!
with self.assertRaisesRegex(RuntimeError, "no_value"):
self.kp["no_value"].GetInt()
def test_validation_fails_due_to_wrong_type(self):
kp = Parameters(wrong_type)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_fails_due_to_wrong_spelling(self):
kp = Parameters(wrong_spelling)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_recursive_validation_fails_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.RecursivelyValidateAndAssignDefaults(defaults_params)
def test_validation_succeds_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# here no error shall be thrown since validation is only done on level0
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_succeeds(self):
kp = Parameters(json_string)
defaults_params = Parameters(defaults)
defaults_params["level1"]["tmp"].SetDouble(
2.0
) # this does not coincide with the value in kp, but is of the same type
kp.ValidateAndAssignDefaults(defaults_params)
self.assertEqual(kp.PrettyPrintJsonString(),
expected_validation_output)
self.assertEqual(kp["level1"]["tmp"].GetDouble(),
5.0) # not 2, since kp overwrites the defaults
def test_add_value(self):
kp = Parameters("{}")
kp.AddEmptyValue("new_double").SetDouble(1.0)
self.assertTrue(kp.Has("new_double"))
self.assertEqual(kp["new_double"].GetDouble(), 1.0)
def test_iterators(self):
kp = Parameters(json_string)
#iteration by range
nitems = 0
for iterator in kp:
nitems = nitems + 1
self.assertEqual(nitems, 5)
#iteration by items
for key, value in kp.items():
#print(value.PrettyPrintJsonString())
self.assertEqual(kp[key].PrettyPrintJsonString(),
value.PrettyPrintJsonString())
#print(key,value)
#testing values
expected_values = [
'10', '2.0', 'true', '"hello"',
'{"list_value":[3,"hi",false],"tmp":5.0}'
]
counter = 0
for value in kp.values():
self.assertEqual(value.WriteJsonString(), expected_values[counter])
counter += 1
#testing values
expected_keys = [
'int_value', 'double_value', 'bool_value', 'string_value', 'level1'
]
counter = 0
for key in kp.keys():
self.assertEqual(key, expected_keys[counter])
counter += 1
def test_remove_value(self):
kp = Parameters(json_string)
self.assertTrue(kp.Has("int_value"))
self.assertTrue(kp.Has("level1"))
print(kp)
kp.RemoveValue("int_value")
kp.RemoveValue("level1")
print(kp)
self.assertFalse(kp.Has("int_value"))
self.assertFalse(kp.Has("level1"))
class TestParameters(KratosUnittest.TestCase):
def setUp(self):
self.kp = Parameters(json_string)
self.compact_expected_output = """{"int_value":10,"double_value":2.0,"bool_value":true,"string_value":"hello","level1":{"list_value":[3,"hi",false],"tmp":5.0}}"""
if (sys.version_info < (3, 2)):
self.assertRaisesRegex = self.assertRaisesRegexp
def test_kratos_parameters(self):
self.assertEqual(self.kp.WriteJsonString(),
self.compact_expected_output)
self.assertTrue(self.kp.Has("int_value"))
self.assertFalse(self.kp.Has("unextisting_value"))
self.assertEqual(self.kp["int_value"].GetInt(), 10)
self.assertEqual(self.kp["double_value"].GetDouble(), 2.0)
self.assertEqual(self.kp["bool_value"].GetBool(), True)
self.assertEqual(self.kp["string_value"].GetString(), "hello")
self.assertEqual(self.kp.PrettyPrintJsonString(), pretty_out)
def test_kratos_change_parameters(self):
# now change one item in the sublist
subparams = self.kp["level1"]
my_list = subparams["list_value"]
for i in range(my_list.size()):
if my_list[i].IsBool():
self.assertEqual(my_list[i].GetBool(), False)
# my_list = subparams["list_value"]
subparams["list_value"][0].SetString("changed")
self.assertEqual(self.kp.PrettyPrintJsonString(),
pretty_out_after_change)
def test_kratos_copy_parameters(self):
# try to make a copy
original_out = self.kp.PrettyPrintJsonString()
other_copy = self.kp.Clone()
self.assertEqual(other_copy.PrettyPrintJsonString(), original_out)
other_copy["int_value"].SetInt(-1)
self.assertEqual(self.kp["int_value"].GetInt(), 10)
# self.assertEqual(other_copy["int_value").GetString(),-1)
def test_set_value(self):
kp = Parameters(json_string)
kp1 = Parameters(pretty_out_after_change)
kp["bool_value"] = kp1["level1"]
kp["bool_value"].PrettyPrintJsonString()
self.assertEqual(kp["bool_value"].PrettyPrintJsonString(),
kp1["level1"].PrettyPrintJsonString())
def test_kratos_wrong_parameters(self):
# should check which errors are thrown!!
with self.assertRaisesRegex(RuntimeError, "no_value"):
self.kp["no_value"].GetInt()
def test_validation_fails_due_to_wrong_type(self):
kp = Parameters(wrong_type)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_fails_due_to_wrong_spelling(self):
kp = Parameters(wrong_spelling)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_recursive_validation_fails_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.RecursivelyValidateAndAssignDefaults(defaults_params)
def test_recursive_validation_4_levels(self):
kp = Parameters(four_levels)
kp_variation = Parameters(four_levels_variation)
kp_wrong_wariation = Parameters(four_levels_wrong_variation)
defaults_params = Parameters(four_levels_defaults)
kp.RecursivelyValidateAndAssignDefaults(defaults_params)
kp_variation.RecursivelyValidateAndAssignDefaults(defaults_params)
self.assertTrue(kp.IsEquivalentTo(defaults_params))
self.assertFalse(kp_variation.IsEquivalentTo(defaults_params))
self.assertTrue(kp.HasSameKeysAndTypeOfValuesAs(defaults_params))
self.assertTrue(
kp_variation.HasSameKeysAndTypeOfValuesAs(defaults_params))
self.assertFalse(
kp_wrong_wariation.HasSameKeysAndTypeOfValuesAs(defaults_params))
def test_validation_succeds_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# here no error shall be thrown since validation is only done on level0
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_succeeds(self):
kp = Parameters(json_string)
defaults_params = Parameters(defaults)
defaults_params["level1"]["tmp"].SetDouble(
2.0
) # this does not coincide with the value in kp, but is of the same type
kp.ValidateAndAssignDefaults(defaults_params)
self.assertEqual(kp.PrettyPrintJsonString(),
expected_validation_output)
self.assertEqual(kp["level1"]["tmp"].GetDouble(),
5.0) # not 2, since kp overwrites the defaults
def test_add_value(self):
kp = Parameters("{}")
kp.AddEmptyValue("new_double").SetDouble(1.0)
self.assertTrue(kp.Has("new_double"))
self.assertEqual(kp["new_double"].GetDouble(), 1.0)
def test_iterators(self):
kp = Parameters(json_string)
#iteration by range
nitems = 0
for iterator in kp:
nitems = nitems + 1
self.assertEqual(nitems, 5)
#iteration by items
for key, value in kp.items():
#print(value.PrettyPrintJsonString())
self.assertEqual(kp[key].PrettyPrintJsonString(),
value.PrettyPrintJsonString())
#print(key,value)
#testing values
expected_values = [
'10', '2.0', 'true', '"hello"',
'{"list_value":[3,"hi",false],"tmp":5.0}'
]
counter = 0
for value in kp.values():
self.assertEqual(value.WriteJsonString(), expected_values[counter])
counter += 1
#testing values
expected_keys = [
'int_value', 'double_value', 'bool_value', 'string_value', 'level1'
]
counter = 0
for key in kp.keys():
self.assertEqual(key, expected_keys[counter])
counter += 1
def test_remove_value(self):
kp = Parameters(json_string)
self.assertTrue(kp.Has("int_value"))
self.assertTrue(kp.Has("level1"))
kp.RemoveValue("int_value")
kp.RemoveValue("level1")
self.assertFalse(kp.Has("int_value"))
self.assertFalse(kp.Has("level1"))
def test_is_methods(self):
# This method checks all the "IsXXX" Methods
tmp = Parameters(
"""{
"int_value" : 10,
"double_value": 2.0,
"bool_value" : true,
"string_value" : "hello",
"vector_value" : [5,3,4],
"matrix_value" : [[1,2],[3,6]]
}"""
) # if you add more values to this, make sure to add the corresponding in the loop
for key in tmp.keys():
val_type = key[:-6] # removing "_value"
if val_type == "int":
self.assertTrue(tmp[key].IsInt())
else:
self.assertFalse(tmp[key].IsInt())
if val_type == "double":
self.assertTrue(tmp[key].IsDouble())
else:
self.assertFalse(tmp[key].IsDouble())
if val_type == "bool":
self.assertTrue(tmp[key].IsBool())
else:
self.assertFalse(tmp[key].IsBool())
if val_type == "string":
self.assertTrue(tmp[key].IsString())
else:
self.assertFalse(tmp[key].IsString())
if val_type == "vector":
self.assertTrue(tmp[key].IsVector())
else:
self.assertFalse(tmp[key].IsVector())
if val_type == "matrix":
self.assertTrue(tmp[key].IsMatrix())
else:
self.assertFalse(tmp[key].IsMatrix())
def test_get_methods(self):
# This method checks all the "GetXXX" Methods if they throw an error
tmp = Parameters(
"""{
"int_value" : 10,
"double_value": 2.0,
"bool_value" : true,
"string_value" : "hello",
"vector_value" : [5.2,-3.1,4.33],
"matrix_value" : [[1,2],[3,4],[5,6]]
}"""
) # if you add more values to this, make sure to add the corresponding in the loop
for key in tmp.keys():
val_type = key[:-6] # removing "_value"
# Int and Double are checked tgth bcs both internally call "IsNumber"
if val_type == "int" or val_type == "double":
if val_type == "int":
self.assertEqual(tmp[key].GetInt(), 10)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetInt()
if val_type == "double" or val_type == "int":
if val_type == "double":
self.assertEqual(tmp[key].GetDouble(), 2.0)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetDouble()
if val_type == "bool":
self.assertEqual(tmp[key].GetBool(), True)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetBool()
if val_type == "string":
self.assertEqual(tmp[key].GetString(), "hello")
else:
with self.assertRaises(RuntimeError):
tmp[key].GetString()
if val_type == "vector":
V = tmp[key].GetVector()
self.assertEqual(V[0], 5.2)
self.assertEqual(V[1], -3.1)
self.assertEqual(V[2], 4.33)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetVector()
if val_type == "matrix":
A = tmp[key].GetMatrix()
self.assertEqual(A[0, 0], 1.0)
self.assertEqual(A[0, 1], 2.0)
self.assertEqual(A[1, 0], 3.0)
self.assertEqual(A[1, 1], 4.0)
self.assertEqual(A[2, 0], 5.0)
self.assertEqual(A[2, 1], 6.0)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetMatrix()
def test_vector_interface(self):
# Read and check Vectors from a Parameters-Object
tmp = Parameters("""{
"valid_vectors" : [ []
],
"false_vectors" : [ [[2,3],2],
[2,3,[2]],
[2,3,[]],
[{"key":3},2],
[2,3,{"key":3}],
[true,2],
[2,3,true],
[5,"string",2]
]
}""")
# Check the IsVector Method
for i in range(tmp["valid_vectors"].size()):
valid_vector = tmp["valid_vectors"][i]
self.assertTrue(valid_vector.IsVector())
for i in range(tmp["false_vectors"].size()):
false_vector = tmp["false_vectors"][i]
self.assertFalse(false_vector.IsVector())
# Check the GetVector Method also on the valid Matrices
for i in range(tmp["valid_vectors"].size()):
valid_vector = tmp["valid_vectors"][i]
valid_vector.GetVector()
# Check that the errors of the GetVector method are thrown correctly
for i in range(tmp["false_vectors"].size()):
false_vector = tmp["false_vectors"][i]
with self.assertRaises(RuntimeError):
false_vector.GetVector()
# Manually assign and check a Vector
vec = Vector(3)
vec[0] = 1.32
vec[1] = -2.22
vec[2] = 5.5
tmp.AddEmptyValue("vector_value")
tmp["vector_value"].SetVector(vec)
self.assertTrue(tmp["vector_value"].IsVector())
V2 = tmp["vector_value"].GetVector()
self.assertEqual(V2[0], 1.32)
self.assertEqual(V2[1], -2.22)
self.assertEqual(V2[2], 5.5)
def test_matrix_interface(self):
# Read and check Matrices from a Parameters-Object
tmp = Parameters("""{
"valid_matrices" : [ [[]],
[[],[]],
[[-9.81,8, 5.47]]
],
"false_matrices" : [ [],
[[[]]],
[[3.3] , [1,2]],
[[2,1.5,3.3] , [3,{"key":3},2]],
[[2,1.5,3.3] , [5,false,2]],
[[2,1.5,3.3] , [[2,3],1,2]],
[[2,1.5,3.3] , ["string",2,9]]
]
}""")
# Check the IsMatrix Method
for i in range(tmp["valid_matrices"].size()):
valid_matrix = tmp["valid_matrices"][i]
self.assertTrue(valid_matrix.IsMatrix())
for i in range(tmp["false_matrices"].size()):
false_matrix = tmp["false_matrices"][i]
self.assertFalse(false_matrix.IsMatrix())
# Check the GetMatrix Method also on the valid Matrices
for i in range(tmp["valid_matrices"].size()):
valid_matrix = tmp["valid_matrices"][i]
valid_matrix.GetMatrix()
# Check that the errors of the GetMatrix method are thrown correctly
for i in range(tmp["false_matrices"].size()):
false_matrix = tmp["false_matrices"][i]
with self.assertRaises(RuntimeError):
false_matrix.GetMatrix()
# Manually assign and check a Matrix
mat = Matrix(3, 2)
mat[0, 0] = 1.0
mat[0, 1] = 2.0
mat[1, 0] = 3.0
mat[1, 1] = 4.0
mat[2, 0] = 5.0
mat[2, 1] = 6.0
tmp.AddEmptyValue("matrix_value")
tmp["matrix_value"].SetMatrix(mat)
self.assertTrue(tmp["matrix_value"].IsMatrix())
A2 = tmp["matrix_value"].GetMatrix()
self.assertEqual(A2[0, 0], 1.0)
self.assertEqual(A2[0, 1], 2.0)
self.assertEqual(A2[1, 0], 3.0)
self.assertEqual(A2[1, 1], 4.0)
self.assertEqual(A2[2, 0], 5.0)
self.assertEqual(A2[2, 1], 6.0)
def test_null_vs_null_validation(self):
# supplied settings
null_custom = Parameters("""{
"parameter": null
}""")
# default settings
null_default = Parameters("""{
"parameter": null
}""")
#this should NOT raise, hence making the test to pass
null_custom.ValidateAndAssignDefaults(null_default)
def test_double_vs_null_validation(self):
# supplied settings
double_custom = Parameters("""{
"parameter": 0.0
}""")
# default settings
null_default = Parameters("""{
"parameter": null
}""")
with self.assertRaises(RuntimeError):
double_custom.ValidateAndAssignDefaults(null_default)
def test_add_empty_array(self):
kp = Parameters("{}")
kp.AddEmptyArray("new_array")
self.assertTrue(kp.Has("new_array"))
self.assertEqual(kp["new_array"].size(), 0)
class TestParameters(KratosUnittest.TestCase):
def setUp(self):
self.kp = Parameters(json_string)
self.compact_expected_output = """{"bool_value":true,"double_value":2.0,"int_value":10,"level1":{"list_value":[3,"hi",false],"tmp":5.0},"string_value":"hello"}"""
def test_kratos_parameters(self):
self.assertEqual(
self.kp.WriteJsonString(),
self.compact_expected_output
)
self.assertTrue(self.kp.Has("int_value"))
self.assertFalse(self.kp.Has("unextisting_value"))
self.assertEqual(self.kp["int_value"].GetInt(), 10)
self.assertEqual(self.kp["double_value"].GetDouble(), 2.0)
self.assertEqual(self.kp["bool_value"].GetBool(), True)
self.assertEqual(self.kp["string_value"].GetString(), "hello")
self.assertEqual(self.kp.PrettyPrintJsonString(), pretty_out)
def test_kratos_change_parameters(self):
# now change one item in the sublist
subparams = self.kp["level1"]
my_list = subparams["list_value"]
for i in range(my_list.size()):
if my_list[i].IsBool():
self.assertEqual(my_list[i].GetBool(), False)
# my_list = subparams["list_value"]
subparams["list_value"][0].SetString("changed")
self.assertEqual(
self.kp.PrettyPrintJsonString(),
pretty_out_after_change
)
def test_kratos_copy_parameters(self):
# try to make a copy
original_out = self.kp.PrettyPrintJsonString()
other_copy = self.kp.Clone()
self.assertEqual(
other_copy.PrettyPrintJsonString(),
original_out
)
other_copy["int_value"].SetInt(-1)
self.assertEqual(self.kp["int_value"].GetInt(), 10)
# self.assertEqual(other_copy["int_value").GetString(),-1)
def test_set_value(self):
kp = Parameters(json_string)
kp1 = Parameters(pretty_out_after_change)
kp["bool_value"] = kp1["level1"]
kp["bool_value"].PrettyPrintJsonString()
self.assertEqual(kp["bool_value"].PrettyPrintJsonString(), kp1["level1"].PrettyPrintJsonString())
def test_kratos_wrong_parameters(self):
# should check which errors are thrown!!
with self.assertRaisesRegex(RuntimeError, "no_value"):
self.kp["no_value"].GetInt()
def test_validation_fails_due_to_wrong_type(self):
kp = Parameters(wrong_type)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_fails_due_to_wrong_spelling(self):
kp = Parameters(wrong_spelling)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.ValidateAndAssignDefaults(defaults_params)
def test_recursive_validation_fails_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# should check which errors are thrown!!
with self.assertRaises(RuntimeError):
kp.RecursivelyValidateAndAssignDefaults(defaults_params)
def test_recursive_validation_4_levels(self):
kp = Parameters(four_levels)
kp_variation = Parameters(four_levels_variation)
kp_wrong_wariation = Parameters(four_levels_wrong_variation)
defaults_params = Parameters(four_levels_defaults)
kp.RecursivelyValidateAndAssignDefaults(defaults_params)
kp_variation.RecursivelyValidateAndAssignDefaults(defaults_params)
self.assertTrue( kp.IsEquivalentTo(defaults_params) )
self.assertFalse( kp_variation.IsEquivalentTo(defaults_params) )
self.assertTrue( kp.HasSameKeysAndTypeOfValuesAs(defaults_params) )
self.assertTrue( kp_variation.HasSameKeysAndTypeOfValuesAs(defaults_params) )
self.assertFalse( kp_wrong_wariation.HasSameKeysAndTypeOfValuesAs(defaults_params) )
def test_validation_succeds_error_on_first_level(self):
kp = Parameters(wrong_lev2)
defaults_params = Parameters(defaults)
# here no error shall be thrown since validation is only done on level0
kp.ValidateAndAssignDefaults(defaults_params)
def test_validation_succeeds(self):
kp = Parameters(json_string)
defaults_params = Parameters(defaults)
defaults_params["level1"]["tmp"].SetDouble(2.0) # this does not coincide with the value in kp, but is of the same type
kp.ValidateAndAssignDefaults(defaults_params)
self.assertEqual(kp.PrettyPrintJsonString(), expected_validation_output)
self.assertEqual(kp["level1"]["tmp"].GetDouble(), 5.0) # not 2, since kp overwrites the defaults
def test_add_missing_parameters(self):
# only missing parameters are added, no complaints if there already exist more than in the defaults
kp = Parameters(json_string)
tmp = Parameters(incomplete_with_extra_parameter)
kp.AddMissingParameters(tmp)
self.assertEqual(kp["new_default_obj"]["aaa"].GetString(), "string")
self.assertEqual(kp["string_value"].GetString(), "hello")
self.assertFalse(kp["level1"].Has("new_sublevel"))
def test_recursively_add_missing_parameters(self):
# only missing parameters are added, no complaints if there already exist more than in the defaults
kp = Parameters(json_string)
tmp = Parameters(incomplete_with_extra_parameter)
kp.RecursivelyAddMissingParameters(tmp)
self.assertTrue(kp["level1"].Has("new_sublevel"))
self.assertEqual(kp["level1"]["new_sublevel"].GetString(), "this should only be assigned in recursive")
def test_validate_defaults(self):
# only parameters from defaults are validated, no new values are added
kp = Parameters(incomplete_with_extra_parameter)
tmp = Parameters(defaults)
kp.ValidateDefaults(tmp)
self.assertFalse(kp.Has("bool_value"))
self.assertFalse(kp.Has("double_value"))
self.assertTrue(kp.Has("level1"))
def test_recursively_validate_defaults(self):
# only parameters from defaults are validated, no new values are added
kp = Parameters(incomplete)
tmp = Parameters(defaults)
kp.RecursivelyValidateDefaults(tmp)
self.assertFalse(kp.Has("bool_value"))
self.assertFalse(kp.Has("double_value"))
self.assertTrue(kp.Has("level1"))
def test_recursively_validate_defaults_fails(self):
# only parameters from defaults are validated, no new values are added
kp = Parameters(incomplete_with_extra_parameter)
tmp = Parameters(defaults)
with self.assertRaises(RuntimeError):
kp.RecursivelyValidateDefaults(tmp)
# sub_level
self.assertFalse(kp["level1"].Has("tmp"))
def test_add_value(self):
kp = Parameters("{}")
kp.AddEmptyValue("new_double").SetDouble(1.0)
self.assertTrue(kp.Has("new_double"))
self.assertEqual(kp["new_double"].GetDouble(), 1.0)
def test_add_empty_array(self):
kp = Parameters("{}")
kp.AddEmptyArray("new_array")
self.assertTrue(kp.Has("new_array"))
self.assertEqual(kp["new_array"].size(), 0)
def test_iterators(self):
kp = Parameters(json_string)
#iteration by range
nitems = 0
for iterator in kp:
nitems = nitems + 1
self.assertEqual(nitems, 5)
#iteration by items
for key,value in kp.items():
#print(value.PrettyPrintJsonString())
self.assertEqual(kp[key].PrettyPrintJsonString(), value.PrettyPrintJsonString())
#print(key,value)
#testing values
expected_values = ['true', '2.0', '10', '{"list_value":[3,"hi",false],"tmp":5.0}','"hello"']
counter = 0
for value in kp.values():
self.assertEqual(value.WriteJsonString(), expected_values[counter])
counter += 1
#testing values
expected_keys = ['bool_value', 'double_value', 'int_value', 'level1', 'string_value']
counter = 0
for key in kp.keys():
self.assertEqual(key, expected_keys[counter])
counter += 1
def test_remove_value(self):
kp = Parameters(json_string)
self.assertTrue(kp.Has("int_value"))
self.assertTrue(kp.Has("level1"))
kp.RemoveValue("int_value")
kp.RemoveValue("level1")
self.assertFalse(kp.Has("int_value"))
self.assertFalse(kp.Has("level1"))
def test_is_methods(self):
# This method checks all the "IsXXX" Methods
tmp = Parameters("""{
"int_value" : 10,
"double_value": 2.0,
"bool_value" : true,
"string_value" : "hello",
"vector_value" : [5,3,4],
"matrix_value" : [[1,2],[3,6]]
}""") # if you add more values to this, make sure to add the corresponding in the loop
for key in tmp.keys():
val_type = key[:-6] # removing "_value"
if val_type == "int":
self.assertTrue(tmp[key].IsInt())
else:
self.assertFalse(tmp[key].IsInt())
if val_type == "double":
self.assertTrue(tmp[key].IsDouble())
else:
self.assertFalse(tmp[key].IsDouble())
if val_type == "bool":
self.assertTrue(tmp[key].IsBool())
else:
self.assertFalse(tmp[key].IsBool())
if val_type == "string":
self.assertTrue(tmp[key].IsString())
else:
self.assertFalse(tmp[key].IsString())
if val_type == "vector":
self.assertTrue(tmp[key].IsVector())
else:
self.assertFalse(tmp[key].IsVector())
if val_type == "matrix":
self.assertTrue(tmp[key].IsMatrix())
else:
self.assertFalse(tmp[key].IsMatrix())
def test_get_methods(self):
# This method checks all the "GetXXX" Methods if they throw an error
tmp = Parameters("""{
"int_value" : 10,
"double_value": 2.0,
"bool_value" : true,
"string_value" : "hello",
"vector_value" : [5.2,-3.1,4.33],
"matrix_value" : [[1,2],[3,4],[5,6]]
}""") # if you add more values to this, make sure to add the corresponding in the loop
for key in tmp.keys():
val_type = key[:-6] # removing "_value"
# Int and Double are checked tgth bcs both internally call "IsNumber"
if val_type == "int" or val_type == "double":
if val_type == "int":
self.assertEqual(tmp[key].GetInt(),10)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetInt()
if val_type == "double" or val_type == "int":
if val_type == "double":
self.assertEqual(tmp[key].GetDouble(),2.0)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetDouble()
if val_type == "bool":
self.assertEqual(tmp[key].GetBool(),True)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetBool()
if val_type == "string":
self.assertEqual(tmp[key].GetString(),"hello")
else:
with self.assertRaises(RuntimeError):
tmp[key].GetString()
if val_type == "vector":
V = tmp[key].GetVector()
self.assertEqual(V[0],5.2)
self.assertEqual(V[1],-3.1)
self.assertEqual(V[2],4.33)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetVector()
if val_type == "matrix":
A = tmp[key].GetMatrix()
self.assertEqual(A[0,0],1.0)
self.assertEqual(A[0,1],2.0)
self.assertEqual(A[1,0],3.0)
self.assertEqual(A[1,1],4.0)
self.assertEqual(A[2,0],5.0)
self.assertEqual(A[2,1],6.0)
else:
with self.assertRaises(RuntimeError):
tmp[key].GetMatrix()
def test_vector_interface(self):
# Read and check Vectors from a Parameters-Object
tmp = Parameters("""{
"valid_vectors" : [ []
],
"false_vectors" : [ [[]],
[[2,3],2],
[2,3,[2]],
[2,3,[]],
[{"key":3},2],
[2,3,{"key":3}],
[true,2],
[2,3,true],
[5,"string",2]
]
}""")
# Check the IsVector Method
for i in range(tmp["valid_vectors"].size()):
valid_vector = tmp["valid_vectors"][i]
self.assertTrue(valid_vector.IsVector())
for i in range(tmp["false_vectors"].size()):
false_vector = tmp["false_vectors"][i]
self.assertFalse(false_vector.IsVector())
# Check the GetVector Method also on the valid Matrices
for i in range(tmp["valid_vectors"].size()):
valid_vector = tmp["valid_vectors"][i]
valid_vector.GetVector()
# Check that the errors of the GetVector method are thrown correctly
for i in range(tmp["false_vectors"].size()):
false_vector = tmp["false_vectors"][i]
with self.assertRaises(RuntimeError):
false_vector.GetVector()
# Manually assign and check a Vector
vec = Vector(3)
vec[0] = 1.32
vec[1] = -2.22
vec[2] = 5.5
tmp.AddEmptyValue("vector_value")
tmp["vector_value"].SetVector(vec)
self.assertTrue(tmp["vector_value"].IsVector())
V2 = tmp["vector_value"].GetVector()
self.assertEqual(V2[0],1.32)
self.assertEqual(V2[1],-2.22)
self.assertEqual(V2[2],5.5)
def test_matrix_interface(self):
# Read and check Matrices from a Parameters-Object
tmp = Parameters("""{
"valid_matrices" : [ [[]],
[[],[]],
[[-9.81,8, 5.47]]
],
"false_matrices" : [ [],
[[[]]],
[[3.3] , [1,2]],
[[2,1.5,3.3] , [3,{"key":3},2]],
[[2,1.5,3.3] , [5,false,2]],
[[2,1.5,3.3] , [[2,3],1,2]],
[[2,1.5,3.3] , ["string",2,9]]
]
}""")
# Check the IsMatrix Method
for i in range(tmp["valid_matrices"].size()):
valid_matrix = tmp["valid_matrices"][i]
self.assertTrue(valid_matrix.IsMatrix())
for i in range(tmp["false_matrices"].size()):
false_matrix = tmp["false_matrices"][i]
self.assertFalse(false_matrix.IsMatrix())
# Check the GetMatrix Method also on the valid Matrices
for i in range(tmp["valid_matrices"].size()):
valid_matrix = tmp["valid_matrices"][i]
valid_matrix.GetMatrix()
# Check that the errors of the GetMatrix method are thrown correctly
for i in range(tmp["false_matrices"].size()):
false_matrix = tmp["false_matrices"][i]
with self.assertRaises(RuntimeError):
false_matrix.GetMatrix()
# Manually assign and check a Matrix
mat = Matrix(3,2)
mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 4.0
mat[2,0] = 5.0
mat[2,1] = 6.0
tmp.AddEmptyValue("matrix_value")
tmp["matrix_value"].SetMatrix(mat)
self.assertTrue(tmp["matrix_value"].IsMatrix())
A2 = tmp["matrix_value"].GetMatrix()
self.assertEqual(A2[0,0],1.0)
self.assertEqual(A2[0,1],2.0)
self.assertEqual(A2[1,0],3.0)
self.assertEqual(A2[1,1],4.0)
self.assertEqual(A2[2,0],5.0)
self.assertEqual(A2[2,1],6.0)
def test_null_vs_null_validation(self):
# supplied settings
null_custom = Parameters("""{
"parameter": null
}""")
# default settings
null_default = Parameters("""{
"parameter": null
}""")
#this should NOT raise, hence making the test to pass
null_custom.ValidateAndAssignDefaults(null_default)
def test_double_vs_null_validation(self):
# supplied settings
double_custom = Parameters("""{
"parameter": 0.0
}""")
# default settings
null_default = Parameters("""{
"parameter": null
}""")
with self.assertRaises(RuntimeError):
double_custom.ValidateAndAssignDefaults(null_default)
def test_file_serialization(self):
tmp = Parameters(defaults)
check = tmp.WriteJsonString()
file_name = "parameter_serialization"
serializer = FileSerializer(file_name, SerializerTraceType.SERIALIZER_NO_TRACE)
serializer.Save("ParametersSerialization",tmp)
del(tmp)
del(serializer)
#unpickle data - note that here i override "serialized_data"
serializer = FileSerializer(file_name,SerializerTraceType.SERIALIZER_NO_TRACE)
loaded_parameters = Parameters()
serializer.Load("ParametersSerialization",loaded_parameters)
self.assertEqual(check, loaded_parameters.WriteJsonString())
kratos_utils.DeleteFileIfExisting(file_name + ".rest")
def test_get_string_array_valid(self):
tmp = Parameters("""{
"parameter": ["foo", "bar"]
} """)
v = tmp["parameter"].GetStringArray()
self.assertEqual(len(v), 2)
self.assertEqual(v[0], "foo")
self.assertEqual(v[1], "bar")
def test_get_string_array_invalid(self):
tmp = Parameters("""{
"parameter": ["foo", true]
} """)
with self.assertRaisesRegex(RuntimeError, r'Error: Argument must be a string'):
tmp["parameter"].GetStringArray()
@KratosUnittest.skipUnless(have_pickle_module, "Pickle module error: : " + pickle_message)
def test_stream_serialization(self):
tmp = Parameters(defaults)
check = tmp.WriteJsonString()
serializer = StreamSerializer(SerializerTraceType.SERIALIZER_NO_TRACE)
serializer.Save("ParametersSerialization",tmp)
del(tmp)
#pickle dataserialized_data
pickled_data = pickle.dumps(serializer, protocol=2) # Second argument is the protocol and is NECESSARY (according to pybind11 docs)
del(serializer)
#unpickle data - note that here i override "serialized_data"
serializer = pickle.loads(pickled_data)
loaded_parameters = Parameters()
serializer.Load("ParametersSerialization",loaded_parameters)
self.assertEqual(check, loaded_parameters.WriteJsonString())
def __init__(self,
model: KratosMultiphysics.Model,
parameters: KratosMultiphysics.Parameters):
"""Impose a rotation followed by translation on a ModelPart."""
KratosMultiphysics.Process.__init__(self)
# 'rotation_angle' can either be a float or "End", but the validator can't handle both
# => convert 'rotation_angle' to the input type
default_parameters = self.GetDefaultParameters()
if parameters.Has("rotation_angle") and parameters["rotation_angle"].IsString():
default_parameters.RemoveValue("rotation_angle")
default_parameters.AddValue("rotation_angle", parameters["rotation_angle"])
parameters.ValidateAndAssignDefaults(default_parameters)
self.model_part = model[parameters["model_part_name"].GetString()]
# Parse interval
self.interval_utility = KratosMultiphysics.IntervalUtility(parameters)
# Determine whether a constant transform will suffice or a parametric one is needed
requires_parametric_transform = False
euler_angle_parameters = parameters["euler_angles"]
rotation_axis_parameters = parameters["rotation_axis"]
rotation_angle_parameters = parameters["rotation_angle"]
reference_point_parameters = parameters["reference_point"]
translation_vector_parameters = parameters["translation_vector"]
if rotation_angle_parameters.IsString():
requires_parametric_transform = True
else:
for i in range(3):
if euler_angle_parameters[i].IsString() or rotation_axis_parameters[i].IsString() or reference_point_parameters[i].IsString() or translation_vector_parameters[i].IsString():
requires_parametric_transform = True
break
rotation_definition = parameters["rotation_definition"].GetString()
if requires_parametric_transform:
if rotation_definition == "rotation_axis":
self.transform = MeshMovingApplication.ParametricLinearTransform(
rotation_axis_parameters,
rotation_angle_parameters,
reference_point_parameters,
translation_vector_parameters)
elif rotation_definition == "euler_angles":
self.transform = MeshMovingApplication.ParametricLinearTransform(
euler_angle_parameters,
reference_point_parameters,
translation_vector_parameters)
else:
raise ValueError("Invalid rotation definition '{}'".format(rotation_definition))
else:
reference_point = reference_point_parameters.GetVector()
translation_vector = translation_vector_parameters.GetVector()
if rotation_definition == "rotation_axis":
rotation_axis = rotation_axis_parameters.GetVector()
rotation_angle = rotation_angle_parameters.GetDouble()
self.transform = MeshMovingApplication.LinearTransform(
rotation_axis,
rotation_angle,
reference_point,
translation_vector)
elif rotation_definition == "euler_angles":
euler_angles = euler_angle_parameters.GetVector()
self.transform = MeshMovingApplication.LinearTransform(
euler_angles,
reference_point,
translation_vector)
else:
raise ValueError("Invalid rotation definition '{}'".format(rotation_definition))
def __init__(self, identifier, response_settings, model):
default_parameters = KratosMultiphysics.Parameters( """
{
"response_type": "stochastic_adjoint_lift_potential_jump",
"risk_measure": "expected_value",
"primal_settings": "",
"adjoint_settings": "",
"xmc_settings": "",
"design_surface_sub_model_part_name": "",
"auxiliary_mdpa_path": "auxiliary_mdpa",
"primal_data_transfer_with_python": true,
"output_dict_results_file_name": "",
"output_pressure_file_path": ""
} """ )
response_settings.ValidateAndAssignDefaults(default_parameters)
self.identifier = identifier
self.response_settings = response_settings
if not response_settings["primal_settings"].GetString() == "":
self.primal_settings = response_settings["primal_settings"].GetString()
else:
raise Exception("Please set the path to the primal parameters in \"primal_settings\"")
if not response_settings["adjoint_settings"].GetString() == "":
self.adjoint_settings = response_settings["adjoint_settings"].GetString()
else:
raise Exception("Please set the path to the adjoint parameters in \"adjoint_settings\"")
if not response_settings["xmc_settings"].GetString() == "":
self.xmc_settings_path = response_settings["xmc_settings"].GetString()
else:
raise Exception("Please set the path to the XMC parameters in \"xmc_settings\"")
if not response_settings["design_surface_sub_model_part_name"].GetString() == "":
self.design_surface_sub_model_part_name = response_settings["design_surface_sub_model_part_name"].GetString()
else:
raise Exception("Please set the name of the design surface submodelpart in \"design_surface_sub_model_part_name\"")
self.auxiliary_mdpa_path = response_settings["auxiliary_mdpa_path"].GetString()
self.risk_measure = response_settings["risk_measure"].GetString()
if response_settings.Has("output_dict_results_file_name"):
self.output_dict_results_file_name = response_settings["output_dict_results_file_name"].GetString()
self.results_dict = {}
else:
self.output_dict_results_file_name = ""
if response_settings.Has("output_pressure_file_path"):
self.output_pressure_file_path = response_settings["output_pressure_file_path"].GetString()
else:
self.output_pressure_file_path = ""
# Create the primal solver
with open(self.response_settings["primal_settings"].GetString(),'r') as parameter_file:
primal_parameters = Parameters( parameter_file.read() )
primal_parameters = _CheckParameters(primal_parameters)
if primal_parameters.Has("adjoint_parameters_path"):
primal_parameters["adjoint_parameters_path"].SetString(self.response_settings["adjoint_settings"].GetString())
else:
primal_parameters.AddString("adjoint_parameters_path", self.response_settings["adjoint_settings"].GetString())
if primal_parameters.Has("design_surface_sub_model_part_name"):
primal_parameters["design_surface_sub_model_part_name"].SetString(self.design_surface_sub_model_part_name)
else:
primal_parameters.AddString("design_surface_sub_model_part_name", self.design_surface_sub_model_part_name)
if primal_parameters.Has("auxiliary_mdpa_path"):
primal_parameters["auxiliary_mdpa_path"].SetString(self.auxiliary_mdpa_path)
else:
primal_parameters.AddString("auxiliary_mdpa_path", self.auxiliary_mdpa_path)
open(self.response_settings["primal_settings"].GetString(), 'w').write(primal_parameters.PrettyPrintJsonString())
# Store current design
self.current_model_part = _GetModelPart(model, primal_parameters["solver_settings"])
