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)