def __init__(self, identifier, project_parameters, model):
self.identifier = identifier
# Create the primal solver
with open(project_parameters["primal_settings"].GetString(),
'r') as parameter_file:
ProjectParametersPrimal = Parameters(parameter_file.read())
self.primal_model_part = _GetModelPart(
model, ProjectParametersPrimal["solver_settings"])
self.primal_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
model, ProjectParametersPrimal)
# Create the adjoint solver
with open(project_parameters["adjoint_settings"].GetString(),
'r') as parameter_file:
ProjectParametersAdjoint = Parameters(parameter_file.read())
ProjectParametersAdjoint["solver_settings"].AddValue(
"response_function_settings", project_parameters)
adjoint_model = KratosMultiphysics.Model()
self.adjoint_model_part = _GetModelPart(
adjoint_model, ProjectParametersAdjoint["solver_settings"])
# TODO find out why it is not possible to use the same model_part
self.adjoint_analysis = structural_mechanics_analysis.StructuralMechanicsAnalysis(
adjoint_model, ProjectParametersAdjoint)
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_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_matrix_interface(self):
# Read and check a Matrix from a Parameters-Object
tmp = Parameters("""{
"false_matrix_value": [[2, 1.5,3.3],[1,2]]
}""")
# 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)
# Check the IsMatrix Method
self.assertFalse(
tmp["false_matrix_value"].IsMatrix()) # Mis-sized Matrix
# check that the errors of the GetMatrix method are thrown correctly
with self.assertRaises(RuntimeError):
tmp["false_matrix_value"].GetMatrix() # Mis-sized Matrix
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_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_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_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_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_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_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_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_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_set_string_array_valid(self):
initial = Parameters("""{
"parameter": ["foo", "bar"]
} """)
string_array = initial["parameter"].GetStringArray()
new_param = Parameters()
new_param.AddEmptyValue("new_parameter")
new_param["new_parameter"].SetStringArray(string_array)
new_string_array = initial["parameter"].GetStringArray()
self.assertListEqual(new_string_array, string_array)
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_get_string_array_invalid(self):
tmp = Parameters("""{
"parameter": ["foo", true]
} """)
with self.assertRaisesRegex(RuntimeError,
r'Error: Argument must be a string'):
tmp["parameter"].GetStringArray()
def _GetAdjointParameters(self):
with open(self.response_settings["adjoint_settings"].GetString(),
'r') as parameter_file:
adjoint_parameters = Parameters(parameter_file.read())
if self.response_settings["transfer_response_parameters"].GetBool():
# sensitivity settings
if adjoint_parameters["solver_settings"].Has(
"sensitivity_settings"):
Logger.PrintWarning(
self._GetLabel(),
"Adjoint settings already have 'sensitivity_settings' - Will be overwritten!"
)
adjoint_parameters["solver_settings"].RemoveValue(
"sensitivity_settings")
adjoint_parameters["solver_settings"].AddValue(
"sensitivity_settings",
self.response_settings["sensitivity_settings"])
# response settings
if adjoint_parameters["solver_settings"].Has(
"response_function_settings"):
Logger.PrintWarning(
self._GetLabel(),
"Adjoint settings already have 'response_function_settings' - Will be overwritten!"
)
adjoint_parameters["solver_settings"].RemoveValue(
"response_function_settings")
adjoint_parameters["solver_settings"].AddValue(
"response_function_settings", self.response_settings)
return adjoint_parameters
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
self.response_settings = response_settings
# Create the primal solver
with open(self.response_settings["primal_settings"].GetString(),
'r') as parameter_file:
primal_parameters = Parameters(parameter_file.read())
primal_parameters = self._CheckParameters(primal_parameters)
self.primal_model_part = _GetModelPart(
model, primal_parameters["solver_settings"])
self.primal_analysis = potential_flow_analysis.PotentialFlowAnalysis(
model, primal_parameters)
self.primal_data_transfer_with_python = self.response_settings[
"primal_data_transfer_with_python"].GetBool()
# Create the adjoint solver
adjoint_parameters = self._CheckParameters(
self._GetAdjointParameters())
adjoint_model = KratosMultiphysics.Model()
self.adjoint_model_part = _GetModelPart(
adjoint_model, adjoint_parameters["solver_settings"])
self.adjoint_analysis = potential_flow_analysis.PotentialFlowAnalysis(
adjoint_model, adjoint_parameters)
self.primal_state_variables = [
KCPFApp.VELOCITY_POTENTIAL, KCPFApp.AUXILIARY_VELOCITY_POTENTIAL
]
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
self.response_settings = response_settings
# Create the primal solver
with open(self.response_settings["primal_settings"].GetString(),'r') as parameter_file:
primal_parameters = Parameters( parameter_file.read() )
self.primal_analysis = ConvectionDiffusionAnalysis(model, primal_parameters)
self.primal_model_part = model.GetModelPart(primal_parameters["solver_settings"]["model_part_name"].GetString())
# Create the adjoint solver
adjoint_parameters = self._GetAdjointParameters()
self.adjoint_analysis = ConvectionDiffusionAnalysis(model, adjoint_parameters)
self.adjoint_model_part = model.GetModelPart(adjoint_parameters["solver_settings"]["model_part_name"].GetString())
self.primal_state_variables = [
KM.CONDUCTIVITY,
KM.TEMPERATURE,
KM.HEAT_FLUX,
KM.FACE_HEAT_FLUX
]
self.value = None
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
with open(response_settings["primal_settings"].GetString()) as parameters_file:
ProjectParametersPrimal = Parameters(parameters_file.read())
eigen_solver_settings = ProjectParametersPrimal["solver_settings"]["eigensolver_settings"]
max_required_eigenfrequency = int(max(response_settings["traced_eigenfrequencies"].GetVector()))
if max_required_eigenfrequency is not eigen_solver_settings["number_of_eigenvalues"].GetInt():
Logger.PrintWarning("EigenFrequencyResponse", "Specified number of eigenvalues in the primal analysis and the max required eigenvalue according the response settings do not match!!!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
eigen_solver_settings["number_of_eigenvalues"].SetInt(max_required_eigenfrequency)
if not eigen_solver_settings.Has("normalize_eigenvectors"):
eigen_solver_settings.AddEmptyValue("normalize_eigenvectors")
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
if not eigen_solver_settings["normalize_eigenvectors"].GetBool():
eigen_solver_settings["normalize_eigenvectors"].SetBool(True)
Logger.PrintWarning("EigenFrequencyResponse", "Eigenfrequency response function requires mass normalization of eigenvectors!")
Logger.PrintWarning("EigenFrequencyResponse", "Primal parameters were adjusted accordingly!\n")
self.primal_model_part = _GetModelPart(model, ProjectParametersPrimal["solver_settings"])
self.primal_analysis = StructuralMechanicsAnalysis(model, ProjectParametersPrimal)
self.primal_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.SHAPE_SENSITIVITY)
self.response_function_utility = StructuralMechanicsApplication.EigenfrequencyResponseFunctionUtility(self.primal_model_part, response_settings)
def __init__(self, identifier, response_settings, model):
self.identifier = identifier
self.response_settings = response_settings
# Create the primal solver
with open(self.response_settings["primal_settings"].GetString(),
'r') as parameter_file:
primal_parameters = Parameters(parameter_file.read())
self.primal_model_part = _GetModelPart(
model, primal_parameters["solver_settings"])
self.primal_analysis = StructuralMechanicsAnalysis(
model, primal_parameters)
self.primal_data_transfer_with_python = self.response_settings[
"primal_data_transfer_with_python"].GetBool()
# Create the adjoint solver
adjoint_parameters = self._GetAdjointParameters()
adjoint_model = KratosMultiphysics.Model()
self.adjoint_model_part = _GetModelPart(
adjoint_model, adjoint_parameters["solver_settings"])
# TODO find out why it is not possible to use the same model_part
self.adjoint_analysis = StructuralMechanicsAnalysis(
adjoint_model, adjoint_parameters)
self.primal_state_variables = [KratosMultiphysics.DISPLACEMENT]
if primal_parameters["solver_settings"].Has("rotation_dofs"):
if primal_parameters["solver_settings"]["rotation_dofs"].GetBool():
self.primal_state_variables.append(KratosMultiphysics.ROTATION)
def __init__(self, model, parameters=Parameters("{}")):
sys.stdout = SDEMLogger()
self.StartTimer()
self.model = model
self.main_path = os.getcwd()
self.SetProjectParameters(parameters)
self.vars_man = variables_management.VariablesManager(
self.project_parameters)
self._GetDEMAnalysis().coupling_analysis = weakref.proxy(self)
self._GetFluidAnalysis().coupling_analysis = weakref.proxy(self)
self.procedures = weakref.proxy(self._GetDEMAnalysis().procedures)
self.report = DP.Report()
self._GetDEMAnalysis().SetAnalyticFaceWatcher()
# defining member variables for the model_parts (for convenience)
self.fluid_model_part = self._GetFluidAnalysis().fluid_model_part
self.spheres_model_part = self._GetDEMAnalysis().spheres_model_part
self.cluster_model_part = self._GetDEMAnalysis().cluster_model_part
self.rigid_face_model_part = self._GetDEMAnalysis(
).rigid_face_model_part
self.dem_inlet_model_part = self._GetDEMAnalysis().dem_inlet_model_part
self.vars_man.ConstructListsOfVariables(self.project_parameters)
super(SwimmingDEMAnalysis, self).__init__(model,
self.project_parameters)
def test_vector_interface(self):
tmp = Parameters("""{ }""")
# 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_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_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, /* This is comment to check that comments work */
"double_value": 2.0, // This is comment too, but using another comment
"bool_value" : true, // This is another comment being meta as realizing that all the possibilities are already check
"string_value" : "hello",/* This is a nihilist comment about the futile existence of the previous comment as a metacomment */
"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_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 __init__(self, varying_parameters=Parameters("{}")):
BaseAnalysis.__init__(self, varying_parameters)
final_time = self.project_parameters.AddEmptyValue(
"FinalTime").GetDouble()
L = 0.0048 # the channel width
center_x = 0.0044
self.bbox_watcher = SDEM.BoundingBoxRule(0.0, 2 * final_time,
center_x - L, center_x + L,
-0.007, -0.002, -0.005, 0.001)
def __init__(self, varying_parameters=Parameters("{}")):
BaseAnalysis.__init__(self, varying_parameters)
self.project_parameters.do_search_neighbours = False
self.project_parameters.vorticity_calculation_type = 0
self.project_parameters.do_impose_flow_from_field = True
self.project_parameters.L = 0.1
self.project_parameters.U = 0.3
self.project_parameters.k = 2.72
self.project_parameters.omega = math.pi
def __init__(self,
model,
algorithm=None,
varying_parameters=Parameters("{}")):
self.alg = algorithm
if self.alg == None:
import KratosMultiphysics.SwimmingDEMApplication.swimming_DEM_PFEM_algorithm as swimming_DEM_PFEM_algorithm
self.alg = swimming_DEM_PFEM_algorithm.Algorithm(
model, varying_parameters)
