def setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_parameters.json",'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) # The mechanical solver selects automatically the fastest linear-solver available # this might not be appropriate for a test, therefore in case nothing is specified, # the previous default linear-solver is set if not ProjectParameters["solver_settings"].Has("linear_solver_settings"): default_lin_solver_settings = KratosMultiphysics.Parameters("""{ "solver_type": "ExternalSolversApplication.super_lu", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "symmetric_scaling": true, "verbosity": 0 }""") ProjectParameters["solver_settings"].AddValue("linear_solver_settings", default_lin_solver_settings) self.modify_parameters(ProjectParameters) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize()
class IgaTestFactory(KratosUnittest.TestCase): def setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_project_parameters.json",'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize() def test_execution(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.RunSolutionLoop() def tearDown(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.Finalize()
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 setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_parameters.json", 'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters( parameter_file.read()) SelectAndVerifyLinearSolver(ProjectParameters, self.skipTest) self.modify_parameters(ProjectParameters) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize()
class StructuralMechanicsTestFactory(KratosUnittest.TestCase): def setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_parameters.json",'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters(parameter_file.read()) # The mechanical solver selects automatically the fastest linear-solver available # this might not be appropriate for a test, therefore in case nothing is specified, # the previous default linear-solver is set if not ProjectParameters["solver_settings"].Has("linear_solver_settings"): # check if running in MPI because there we use a different default linear solver if IsDistributedRun(): default_lin_solver_settings = KratosMultiphysics.Parameters("""{ "solver_type" : "amesos", "amesos_solver_type" : "Amesos_Klu" }""") else: default_lin_solver_settings = KratosMultiphysics.Parameters("""{ "solver_type": "ExternalSolversApplication.super_lu", "max_iteration": 500, "tolerance": 1e-9, "scaling": false, "symmetric_scaling": true, "verbosity": 0 }""") ProjectParameters["solver_settings"].AddValue("linear_solver_settings", default_lin_solver_settings) self.modify_parameters(ProjectParameters) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity(KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize() def modify_parameters(self, project_parameters): """This function can be used in derived classes to modify existing parameters before the execution of the test (e.g. switch to MPI) """ pass def test_execution(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.RunSolutionLoop() def tearDown(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.Finalize()
def setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_parameters.json", 'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters( parameter_file.read()) # The mechanical solver selects automatically the fastest linear-solver available # this might not be appropriate for a test, therefore in case nothing is specified, # the previous default linear-solver is set if not ProjectParameters["solver_settings"].Has( "linear_solver_settings"): # check if running in MPI because there we use a different default linear solver if IsDistributedRun(): default_lin_solver_settings = KratosMultiphysics.Parameters( """{ "solver_type" : "amesos", "amesos_solver_type" : "Amesos_Klu" }""") else: default_lin_solver_settings = KratosMultiphysics.Parameters( """{ "solver_type": "EigenSolversApplication.sparse_lu" }""") ProjectParameters["solver_settings"].AddValue( "linear_solver_settings", default_lin_solver_settings) solver_type = ProjectParameters["solver_settings"][ "linear_solver_settings"]["solver_type"].GetString() solver_type_splitted = solver_type.split(".") if len(solver_type_splitted) == 2: # this means that we use a solver from an application # hence we have to check if it exists, otherwise skip the test app_name = solver_type_splitted[0] solver_name = solver_type_splitted[1] if not kratos_utils.CheckIfApplicationsAvailable(app_name): self.skipTest( 'Application "{}" is needed for the specified solver "{}" but is not available' .format(app_name, solver_name)) self.modify_parameters(ProjectParameters) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize()
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()) 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.StrainEnergyResponseFunctionUtility(self.primal_model_part, response_settings)
def execute_test_eigen_with_constraints(self, use_block_builder): analysis_parameters = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "eigen_value", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "rotation_dofs" : true, "block_builder" : true } }""") analysis_parameters["solver_settings"]["block_builder"].SetBool( use_block_builder) analysis_parameters_with_constraints = analysis_parameters.Clone() analysis_parameters_with_constraints["solver_settings"][ "block_builder"].SetBool( True ) # Currently the EliminationB&S does not reliably work with constraints model = KratosMultiphysics.Model() analysis = StructuralMechanicsAnalysis(model, analysis_parameters.Clone()) model_part = model["Structure"] SetupSystem(model_part, use_constraints=False) analysis.Run() model_with_constraints = KratosMultiphysics.Model() analysis_with_constraints = StructuralMechanicsAnalysisWithConstraints( model_with_constraints, analysis_parameters_with_constraints) model_part_with_constraints = model_with_constraints["Structure"] SetupSystem(model_part_with_constraints, use_constraints=True) analysis_with_constraints.Run() self.__CompareEigenSolution(model_part, model_part_with_constraints) self.__CompareEigenSolutionMasterSlave(model_part_with_constraints)
def test_cook_membrane_2d(self): results_filename = "cook_membrane_test/cook_membrane_results.json" parameters_filename = "cook_membrane_test/cook_membrane_parameters.json" with open(parameters_filename,'r') as parameter_file: parameters = KratosMultiphysics.Parameters(parameter_file.read()) model = KratosMultiphysics.Model() simulation = StructuralMechanicsAnalysis(model, parameters) simulation.Run() # self._check_results(model_part, A, b) if self.print_results: self.__print_results(model, results_filename) if self.print_output: self.__post_process(model.GetModelPart(parameters["solver_settings"]["model_part_name"].GetString())) self.__check_results(model, results_filename)
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 execute_test_eigen_with_different_dofs(self, use_block_builder): with open(GetFilePath("eigen_test/Eigen_different_dofs_parameters.json"),'r') as parameter_file: parameters = KM.Parameters(parameter_file.read()) parameters["solver_settings"]["block_builder"].SetBool(use_block_builder) model = KM.Model() StructuralMechanicsAnalysis(model, parameters).Run() self.__CheckEigenSolution(model["Structure"])
class StructuralMechanicsTestFactory(KratosUnittest.TestCase): def setUp(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): # Reading the ProjectParameters with open(self.file_name + "_parameters.json", 'r') as parameter_file: ProjectParameters = KratosMultiphysics.Parameters( parameter_file.read()) SelectAndVerifyLinearSolver(ProjectParameters, self.skipTest) self.modify_parameters(ProjectParameters) # To avoid many prints if ProjectParameters["problem_data"]["echo_level"].GetInt() == 0: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.WARNING) else: KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.INFO) # Creating the test model = KratosMultiphysics.Model() self.test = StructuralMechanicsAnalysis(model, ProjectParameters) self.test.Initialize() def modify_parameters(self, project_parameters): """This function can be used in derived classes to modify existing parameters before the execution of the test (e.g. switch to MPI) """ pass def test_execution(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.RunSolutionLoop() def tearDown(self): # Within this location context: with KratosUnittest.WorkFolderScope(".", __file__): self.test.Finalize()
def __init__(self): self.model = Kratos.Model() from KratosMultiphysics.DemStructuresCouplingApplication.dem_main_script_ready_for_coupling_with_fem import StructuresCoupledDEMAnalysisStage dem_parameters_file_name = "ProjectParametersDEM.json" with open(dem_parameters_file_name,'r') as parameter_file: parameters = Kratos.Parameters(parameter_file.read()) self.dem_solution = StructuresCoupledDEMAnalysisStage(self.model, parameters) self.dem_solution.coupling_analysis = weakref.proxy(self) from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis structural_parameters_file_name = "ProjectParameters.json" with open(structural_parameters_file_name,'r') as parameter_file: parameters = Kratos.Parameters(parameter_file.read()) # Create structural solver, main_model_part and added variables self.structural_solution = StructuralMechanicsAnalysis(self.model, parameters) self.AddDEMVariablesToStructural()
def test_eigen_with_constraints(self): analysis_parameters = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "eigen_value", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "use_computing_model_part" : false, "rotation_dofs" : true } }""") model = KratosMultiphysics.Model() analysis = StructuralMechanicsAnalysis(model, analysis_parameters.Clone()) model_part = model["Structure"] SetupSystem(model_part, use_constraints=False) analysis.Run() model_with_constraints = KratosMultiphysics.Model() analysis_with_constraints = StructuralMechanicsAnalysisWithConstraints( model_with_constraints, analysis_parameters.Clone()) model_part_with_constraints = model_with_constraints["Structure"] SetupSystem(model_part_with_constraints, use_constraints=True) analysis_with_constraints.Run() self.__CompareEigenSolution(model_part, model_part_with_constraints)
def test_cook_membrane_incompressible_2d(self): with KratosUnittest.WorkFolderScope(".", __file__): results_filename = "cook_membrane_test/cook_membrane_incompressible_results.json" parameters_filename = "cook_membrane_test/cook_membrane_parameters.json" with open(parameters_filename, 'r') as parameter_file: parameters = KratosMultiphysics.Parameters( parameter_file.read()) parameters["solver_settings"]["material_import_settings"][ "materials_filename"].SetString( "cook_membrane_test/cook_membrane_incompressible_materials.json" ) model = KratosMultiphysics.Model() simulation = StructuralMechanicsAnalysis(model, parameters) simulation.Run() # self._check_results(model_part, A, b) if self.print_results: self.__print_results(model, results_filename) if self.print_output: self.__post_process( model.GetModelPart(parameters["solver_settings"] ["model_part_name"].GetString())) self.__check_results(model, results_filename)
def _createTest(self, problem_dir_name): self.problem_dir_name = problem_dir_name full_parameter_file_name = os.path.join(problem_dir_name,'ProjectParameters.json') with open(full_parameter_file_name, 'r') as parameter_file: self.cable_net_parameters = KM.Parameters(parameter_file.read()) # To avoid many prints echo_level = self.cable_net_parameters["problem_data"]["echo_level"].GetInt() if (echo_level == 0): KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.WARNING) else: KM.Logger.GetDefaultOutput().SetSeverity(KM.Logger.Severity.INFO) model = KM.Model() self.test = StructuralMechanicsAnalysis(model, self.cable_net_parameters)
class AdjointResponseFunction(ResponseFunctionInterface): """Linear static adjoint strain energy response function. - runs the primal analysis (writes the primal results to an .h5 file) - reads the primal results from the .h5 file into the adjoint model part - uses primal results to calculate value - uses primal results to calculate gradient by running the adjoint analysis Attributes ---------- primal_analysis : Primal analysis object of the response function adjoint_analysis : Adjoint analysis object of the response function """ 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 Initialize(self): self.primal_analysis.Initialize() self.adjoint_analysis.Initialize() def InitializeSolutionStep(self): # Run the primal analysis. # TODO if primal_analysis.status==solved: return Logger.PrintInfo(self._GetLabel(), "Starting primal analysis for response:", self.identifier) startTime = timer.time() if not self.primal_analysis.time < self.primal_analysis.end_time: self.primal_analysis.end_time += 1 self.primal_analysis.RunSolutionLoop() Logger.PrintInfo(self._GetLabel(), "Time needed for solving the primal analysis = ", round(timer.time() - startTime, 2), "s") def CalculateValue(self): startTime = timer.time() value = self._GetResponseFunctionUtility().CalculateValue( self.primal_model_part) Logger.PrintInfo(self._GetLabel(), "Time needed for calculating the response value = ", round(timer.time() - startTime, 2), "s") self.primal_model_part.ProcessInfo[ StructuralMechanicsApplication.RESPONSE_VALUE] = value def CalculateGradient(self): # synchronize the modelparts self._SynchronizeAdjointFromPrimal() startTime = timer.time() Logger.PrintInfo(self._GetLabel(), "Starting adjoint analysis for response:", self.identifier) if not self.adjoint_analysis.time < self.adjoint_analysis.end_time: self.adjoint_analysis.end_time += 1 self.adjoint_analysis.RunSolutionLoop() Logger.PrintInfo(self._GetLabel(), "Time needed for solving the adjoint analysis = ", round(timer.time() - startTime, 2), "s") def GetValue(self): return self.primal_model_part.ProcessInfo[ StructuralMechanicsApplication.RESPONSE_VALUE] def GetNodalGradient(self, variable): if variable != KratosMultiphysics.SHAPE_SENSITIVITY: raise RuntimeError("GetNodalGradient: No gradient for {}!".format( variable.Name)) gradient = {} for node in self.adjoint_model_part.Nodes: gradient[node.Id] = node.GetSolutionStepValue(variable) return gradient def Finalize(self): self.primal_analysis.Finalize() self.adjoint_analysis.Finalize() def _GetResponseFunctionUtility(self): return self.adjoint_analysis._GetSolver().response_function def _SynchronizeAdjointFromPrimal(self): Logger.PrintInfo( self._GetLabel(), "Synchronize primal and adjoint modelpart for response:", self.identifier) if len(self.primal_model_part.Nodes) != len( self.adjoint_model_part.Nodes): raise RuntimeError( "_SynchronizeAdjointFromPrimal: Model parts have a different number of nodes!" ) # TODO this should happen automatically for primal_node, adjoint_node in zip(self.primal_model_part.Nodes, self.adjoint_model_part.Nodes): adjoint_node.X0 = primal_node.X0 adjoint_node.Y0 = primal_node.Y0 adjoint_node.Z0 = primal_node.Z0 adjoint_node.X = primal_node.X adjoint_node.Y = primal_node.Y adjoint_node.Z = primal_node.Z # Put primal solution on adjoint model if self.primal_data_transfer_with_python: Logger.PrintInfo(self._GetLabel(), "Transfer primal state to adjoint model part.") variable_utils = KratosMultiphysics.VariableUtils() for variable in self.primal_state_variables: variable_utils.CopyModelPartNodalVar(variable, self.primal_model_part, self.adjoint_model_part, 0) def _GetAdjointParameters(self): adjoint_settings = self.response_settings[ "adjoint_settings"].GetString() if adjoint_settings == "auto": Logger.PrintInfo( self._GetLabel(), "Automatic set up adjoint parameters for response:", self.identifier) if not self.primal_data_transfer_with_python: raise Exception( "Auto setup of adjoint parameters does only support primal data transfer with python." ) with open(self.response_settings["primal_settings"].GetString(), 'r') as parameter_file: primal_parameters = Parameters(parameter_file.read()) # check that HDF5 process is not there if primal_parameters["processes"].Has("list_other_processes"): for i in range( 0, primal_parameters["processes"] ["list_other_processes"].size()): process = primal_parameters["processes"][ "list_other_processes"][i] raise Exception( "Auto setup of adjoint parameters does not support {} in list_other_processes" .format(process["python_module"].GetString())) # clone primal settings as base for adjoint adjoint_parameters = primal_parameters.Clone() # analysis settings solver_settings = adjoint_parameters["solver_settings"] primal_solver_type = solver_settings["solver_type"].GetString() if primal_solver_type != "static": raise Exception( "Auto setup of adjoint parameters does not support {} solver_type. Only available for 'static'" .format(primal_solver_type)) solver_settings["solver_type"].SetString("adjoint_" + primal_solver_type) if not solver_settings.Has("compute_reactions"): solver_settings.AddEmptyValue("compute_reactions") solver_settings["compute_reactions"].SetBool(False) if not solver_settings.Has("move_mesh_flag"): solver_settings.AddEmptyValue("move_mesh_flag") solver_settings["move_mesh_flag"].SetBool(False) if solver_settings.Has("scheme_settings"): depr_msg = '\nDEPRECATION-WARNING: "scheme_settings" is deprecated, please remove it from your json parameters.\n' Logger.PrintWarning(__name__, depr_msg) solver_settings.RemoveValue("scheme_settings") if solver_settings["model_import_settings"][ "input_type"].GetString() == "use_input_model_part": solver_settings["model_import_settings"][ "input_type"].SetString("mdpa") if solver_settings["model_import_settings"].Has( "input_filename"): file_name = solver_settings["model_import_settings"][ "input_filename"].GetString() else: Logger.PrintWarning( self._GetLabel(), "Automatic adjoint settings creator assumes the model_part_name as input_filename." ) solver_settings["model_import_settings"].AddEmptyValue( "input_filename") file_name = solver_settings["model_part_name"].GetString() solver_settings["model_import_settings"][ "input_filename"].SetString(file_name) # Dirichlet conditions: change variables for i in range( 0, primal_parameters["processes"] ["constraints_process_list"].size()): process = adjoint_parameters["processes"][ "constraints_process_list"][i] variable_name = process["Parameters"][ "variable_name"].GetString() process["Parameters"]["variable_name"].SetString("ADJOINT_" + variable_name) # Neumann conditions - do not modify to read the same load values as in primal: # Output process: # TODO how to add the output process? How find out about the variables? if adjoint_parameters.Has("output_processes"): Logger.PrintInfo( self._GetLabel(), "Output process is removed for adjoint analysis. To enable it define adjoint_parameters yourself." ) adjoint_parameters.RemoveValue("output_processes") # sensitivity settings adjoint_parameters["solver_settings"].AddValue( "sensitivity_settings", self.response_settings["sensitivity_settings"]) # response settings adjoint_parameters["solver_settings"].AddValue( "response_function_settings", self.response_settings) else: # adjoint parameters file is explicitely given - do not change it. with open(self.response_settings["adjoint_settings"].GetString(), 'r') as parameter_file: adjoint_parameters = Parameters(parameter_file.read()) return adjoint_parameters def _GetLabel(self): type_labels = { "adjoint_nodal_displacement": "NodalDisplacement", "adjoint_linear_strain_energy": "StrainEnergy", "adjoint_local_stress": "LocalStress", "adjoint_max_stress": "MaxStress", "adjoint_nodal_reaction": "NodalReaction" } response_type = self.response_settings["response_type"].GetString() return "Adjoint" + type_labels[response_type] + "Response"
class StrainEnergyResponseFunction(ResponseFunctionInterface): """Linear strain energy response function. It triggers the primal analysis and uses the primal analysis results to calculate response value and gradient. Attributes ---------- primal_model_part : Model part of the primal analysis object primal_analysis : Primal analysis object of the response function response_function_utility: Cpp utilities object doing the actual computation of response value and gradient. """ 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()) 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.StrainEnergyResponseFunctionUtility( self.primal_model_part, response_settings) def Initialize(self): self.primal_analysis.Initialize() self.response_function_utility.Initialize() def InitializeSolutionStep(self): self.primal_analysis.time = self.primal_analysis._GetSolver( ).AdvanceInTime(self.primal_analysis.time) self.primal_analysis.InitializeSolutionStep() def CalculateValue(self): Logger.PrintInfo("StrainEnergyResponse", "Starting primal analysis for response", self.identifier) startTime = timer.time() self.primal_analysis._GetSolver().Predict() self.primal_analysis._GetSolver().SolveSolutionStep() Logger.PrintInfo("StrainEnergyResponse", "Time needed for solving the primal analysis", round(timer.time() - startTime, 2), "s") startTime = timer.time() value = self.response_function_utility.CalculateValue() self.primal_model_part.ProcessInfo[ StructuralMechanicsApplication.RESPONSE_VALUE] = value Logger.PrintInfo("StrainEnergyResponse", "Time needed for calculating the response value", round(timer.time() - startTime, 2), "s") def CalculateGradient(self): Logger.PrintInfo("StrainEnergyResponse", "Starting gradient calculation for response", self.identifier) startTime = timer.time() self.response_function_utility.CalculateGradient() Logger.PrintInfo("StrainEnergyResponse", "Time needed for calculating gradients", round(timer.time() - startTime, 2), "s") def FinalizeSolutionStep(self): self.primal_analysis.FinalizeSolutionStep() self.primal_analysis.OutputSolutionStep() def Finalize(self): self.primal_analysis.Finalize() def GetValue(self): return self.primal_model_part.ProcessInfo[ StructuralMechanicsApplication.RESPONSE_VALUE] def GetNodalGradient(self, variable): if variable != KratosMultiphysics.SHAPE_SENSITIVITY: raise RuntimeError("GetNodalGradient: No gradient for {}!".format( variable.Name)) gradient = {} for node in self.primal_model_part.Nodes: gradient[node.Id] = node.GetSolutionStepValue(variable) return gradient
def test_custom_scipy_base_solver(self): analysis_parameters_scipy = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_custom_scipy_base_solver", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "rotation_dofs" : true, "builder_and_solver_settings" : { "use_block_builder" : false } } }""") analysis_parameters_eigen = KratosMultiphysics.Parameters("""{ "problem_data" : { "parallel_type" : "OpenMP", "echo_level" : 1, "start_time" : 0.0, "end_time" : 1.0 }, "solver_settings" : { "solver_type" : "eigen_value", "model_part_name" : "Structure", "domain_size" : 3, "model_import_settings" : { "input_type" : "use_input_model_part" }, "time_stepping" : { "time_step" : 1.1 }, "rotation_dofs" : true, "eigensolver_settings" : { "solver_type" : "eigen_eigensystem", "number_of_eigenvalues" : 5, "normalize_eigenvectors": true, "max_iteration" : 10000, "tolerance" : 1e-6 }, "builder_and_solver_settings" : { "use_block_builder" : true } } }""") model_scipy = KratosMultiphysics.Model() analysis_scipy = StructuralMechanicsAnalysis( model_scipy, analysis_parameters_scipy.Clone()) model_part_scipy = model_scipy["Structure"] SetupSystem(model_part_scipy) analysis_scipy.Run() model_eigen = KratosMultiphysics.Model() analysis_eigen = StructuralMechanicsAnalysis( model_eigen, analysis_parameters_eigen.Clone()) model_part_eigen = model_eigen["Structure"] SetupSystem(model_part_eigen) analysis_eigen.Run() self.__CompareEigenSolution(model_part_scipy, model_part_eigen)
class Algorithm(object): def __init__(self): self.model = Kratos.Model() from KratosMultiphysics.DemStructuresCouplingApplication.dem_main_script_ready_for_coupling_with_fem import StructuresCoupledDEMAnalysisStage dem_parameters_file_name = "ProjectParametersDEM.json" with open(dem_parameters_file_name, 'r') as parameter_file: parameters = Kratos.Parameters(parameter_file.read()) self.dem_solution = StructuresCoupledDEMAnalysisStage( self.model, parameters) self.dem_solution.coupling_analysis = weakref.proxy(self) from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis structural_parameters_file_name = "ProjectParameters.json" with open(structural_parameters_file_name, 'r') as parameter_file: parameters = Kratos.Parameters(parameter_file.read()) # Create structural solver, main_model_part and added variables self.structural_solution = StructuralMechanicsAnalysis( self.model, parameters) self.AddDEMVariablesToStructural() def AddDEMVariablesToStructural(self): self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(DemFem.DEM_SURFACE_LOAD) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable( DemFem.BACKUP_LAST_STRUCTURAL_VELOCITY) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable( DemFem.BACKUP_LAST_STRUCTURAL_DISPLACEMENT) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable( DemFem.SMOOTHED_STRUCTURAL_VELOCITY) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.DELTA_DISPLACEMENT) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.DEM_PRESSURE) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.DEM_NODAL_AREA) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.ELASTIC_FORCES) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.CONTACT_FORCES) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable( Dem.TANGENTIAL_ELASTIC_FORCES) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.SHEAR_STRESS) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable( Dem.NON_DIMENSIONAL_VOLUME_WEAR) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(Dem.IMPACT_WEAR) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(DemFem.TARGET_STRESS) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(DemFem.REACTION_STRESS) self.structural_solution._GetSolver( ).main_model_part.AddNodalSolutionStepVariable(DemFem.LOADING_VELOCITY) def Run(self): self.Initialize() self.RunSolutionLoop() self.Finalize() def Initialize(self): self.structural_solution.Initialize() # Reading mdpa self.dem_solution.Initialize() # Adding DEM variables and reading self._DetectStructuresSkin() self._TransferStructuresSkinToDem() self.dem_solution._GetSolver().Initialize() mixed_mp = self.model.CreateModelPart('MixedPart') filename = os.path.join( self.dem_solution.post_path, self.dem_solution.DEM_parameters["problem_name"].GetString()) self.gid_output = dem_structures_coupling_gid_output.DemStructuresCouplingGiDOutput( filename, True, "Binary", "Multiples", True, True, self.structural_solution._GetSolver().GetComputingModelPart(), self.dem_solution.spheres_model_part, self.dem_solution.cluster_model_part, self.dem_solution.rigid_face_model_part, self.dem_solution.contact_model_part, mixed_mp) structures_nodal_results = [ "VOLUME_ACCELERATION", "DEM_SURFACE_LOAD", "REACTION", "TARGET_STRESS", "REACTION_STRESS", "LOADING_VELOCITY" ] dem_nodal_results = ["IS_STICKY", "DEM_STRESS_TENSOR"] clusters_nodal_results = [] rigid_faces_nodal_results = [] contact_model_part_results = ["CONTACT_FAILURE"] mixed_nodal_results = ["DISPLACEMENT", "VELOCITY"] gauss_points_results = ["CAUCHY_STRESS_TENSOR"] self.gid_output.initialize_dem_fem_results( structures_nodal_results, dem_nodal_results, clusters_nodal_results, rigid_faces_nodal_results, contact_model_part_results, mixed_nodal_results, gauss_points_results) def _DetectStructuresSkin(self): skin_detection_parameters = Kratos.Parameters(""" { "name_auxiliar_model_part" : "DetectedByProcessSkinModelPart", "name_auxiliar_condition" : "SurfaceLoadFromDEMCondition", "list_model_parts_to_assign_conditions" : [] } """) computing_model_part = self.structural_solution._GetSolver( ).GetComputingModelPart() if (computing_model_part.ProcessInfo[Kratos.DOMAIN_SIZE] == 2): self.structure_skin_detector = Kratos.SkinDetectionProcess2D( computing_model_part, skin_detection_parameters) elif (computing_model_part.ProcessInfo[Kratos.DOMAIN_SIZE] == 3): self.structure_skin_detector = Kratos.SkinDetectionProcess3D( computing_model_part, skin_detection_parameters) else: print( "No dimensions detected for the structures problem. Exiting.") sys.exit() self.structure_skin_detector.Execute() def _TransferStructuresSkinToDem(self): self.structural_mp = self.structural_solution._GetSolver( ).GetComputingModelPart() self.skin_mp = self.structural_mp.GetSubModelPart( "DetectedByProcessSkinModelPart") dem_walls_mp = self.dem_solution.rigid_face_model_part max_prop_id = 0 for prop in dem_walls_mp.Properties: if prop.Id > max_prop_id: max_prop_id = prop.Id props = Kratos.Properties(max_prop_id + 1) # NOTE: this should be more general props[Dem.FRICTION] = -0.5773502691896257 props[Dem.WALL_COHESION] = 0.0 props[Dem.COMPUTE_WEAR] = False props[Dem.SEVERITY_OF_WEAR] = 0.001 props[Dem.IMPACT_WEAR_SEVERITY] = 0.001 props[Dem.BRINELL_HARDNESS] = 200.0 props[Kratos.YOUNG_MODULUS] = 7e9 props[Kratos.POISSON_RATIO] = 0.16 dem_walls_mp.AddProperties(props) DemFem.DemStructuresCouplingUtilities().TransferStructuresSkinToDem( self.skin_mp, dem_walls_mp, props) def RunSolutionLoop(self): self.dem_solution.step = 0 self.dem_solution.time = 0.0 self.dem_solution.time_old_print = 0.0 self.time_dem = 0.0 self.Dt_structural = self.structural_solution._GetSolver( ).settings["time_stepping"]["time_step"].GetDouble() while self.structural_solution.time < self.structural_solution.end_time: portion_of_the_force_which_is_new = 0.4 DemFem.DemStructuresCouplingUtilities().SmoothLoadTrasferredToFem( self.dem_solution.rigid_face_model_part, portion_of_the_force_which_is_new) self.structural_solution.time = self.structural_solution._GetSolver( ).AdvanceInTime(self.structural_solution.time) self.structural_solution.InitializeSolutionStep() self.structural_solution._GetSolver().Predict() self.structural_solution._GetSolver().SolveSolutionStep() self.structural_solution.FinalizeSolutionStep() self.structural_solution.OutputSolutionStep() time_final_DEM_substepping = self.structural_solution.time self.Dt_DEM = self.dem_solution.spheres_model_part.ProcessInfo.GetValue( Kratos.DELTA_TIME) DemFem.InterpolateStructuralSolutionForDEM( ).SaveStructuralSolution(self.structural_mp) DemFem.ComputeDEMFaceLoadUtility().ClearDEMFaceLoads(self.skin_mp) for self.dem_solution.time_dem in self.yield_DEM_time( self.dem_solution.time, time_final_DEM_substepping, self.Dt_DEM): self.dem_solution.time = self.dem_solution.time + self.dem_solution._GetSolver( ).dt self.dem_solution.step += 1 self.dem_solution.DEMFEMProcedures.UpdateTimeInModelParts( self.dem_solution.all_model_parts, self.dem_solution.time, self.dem_solution._GetSolver().dt, self.dem_solution.step) self.dem_solution.InitializeSolutionStep() DemFem.InterpolateStructuralSolutionForDEM( ).InterpolateStructuralSolution( self.structural_mp, self.Dt_structural, self.structural_solution.time, self.dem_solution._GetSolver().dt, self.dem_solution.time) self.dem_solution.SolverSolve() self.dem_solution.FinalizeSolutionStep() DemFem.ComputeDEMFaceLoadUtility().CalculateDEMFaceLoads( self.skin_mp, self.dem_solution._GetSolver().dt, self.Dt_structural) self.dem_solution.DEMFEMProcedures.MoveAllMeshes( self.dem_solution.all_model_parts, self.dem_solution.time, self.dem_solution._GetSolver().dt) #DEMFEMProcedures.MoveAllMeshesUsingATable(rigid_face_model_part, time, dt) #### PRINTING GRAPHS #### os.chdir(self.dem_solution.graphs_path) self.dem_solution.post_utils.ComputeMeanVelocitiesInTrap( "Average_Velocity.txt", self.dem_solution.time, self.dem_solution.graphs_path) self.dem_solution.materialTest.MeasureForcesAndPressure() self.dem_solution.materialTest.PrintGraph( self.dem_solution.time) self.dem_solution.DEMFEMProcedures.PrintGraph( self.dem_solution.time) self.dem_solution.DEMFEMProcedures.PrintBallsGraph( self.dem_solution.time) self.dem_solution.DEMEnergyCalculator.CalculateEnergyAndPlot( self.dem_solution.time) self.dem_solution.BeforePrintingOperations( self.dem_solution.time) #### GiD IO ########################################## if self.dem_solution.IsTimeToPrintPostProcess(): self.dem_solution._GetSolver().PrepareElementsForPrinting() if self.dem_solution.DEM_parameters[ "ContactMeshOption"].GetBool(): self.dem_solution._GetSolver( ).PrepareContactElementsForPrinting() self.dem_solution.PrintResultsForGid( self.dem_solution.time) self.dem_solution.demio.PrintMultifileLists( self.dem_solution.time, self.dem_solution.post_path) self.dem_solution.time_old_print = self.dem_solution.time self.dem_solution.FinalizeTimeStep(self.dem_solution.time) DemFem.InterpolateStructuralSolutionForDEM( ).RestoreStructuralSolution(self.structural_mp) def ReadDemModelParts(self, starting_node_Id=0, starting_elem_Id=0, starting_cond_Id=0): creator_destructor = self.dem_solution.creator_destructor structures_model_part = self.structural_solution._GetSolver( ).GetComputingModelPart() max_node_Id = creator_destructor.FindMaxNodeIdInModelPart( structures_model_part) max_elem_Id = creator_destructor.FindMaxElementIdInModelPart( structures_model_part) max_cond_Id = creator_destructor.FindMaxConditionIdInModelPart( structures_model_part) self.dem_solution.BaseReadModelParts(max_node_Id, max_elem_Id, max_cond_Id) self.dem_solution.all_model_parts.MaxNodeId = max_node_Id def Finalize(self): self.dem_solution.Finalize() self.structural_solution.Finalize() def yield_DEM_time(self, current_time, current_time_plus_increment, delta_time): current_time += delta_time tolerance = 0.0001 while current_time < (current_time_plus_increment - tolerance * delta_time): yield current_time current_time += delta_time current_time = current_time_plus_increment yield current_time
from __future__ import print_function, absolute_import, division #makes KratosMultiphysics backward compatible with python 2.6 and 2.7 import KratosMultiphysics from KratosMultiphysics.StructuralMechanicsApplication.structural_mechanics_analysis import StructuralMechanicsAnalysis """ For user-scripting it is intended that a new class is derived from StructuralMechanicsAnalysis to do modifications """ if __name__ == "__main__": with open("ProjectParameters.json", 'r') as parameter_file: parameters = KratosMultiphysics.Parameters(parameter_file.read()) model = KratosMultiphysics.Model() simulation = StructuralMechanicsAnalysis(model, parameters) simulation.Run()
def _CreateAnalysisStage(self): return StructuralMechanicsAnalysis(self.model, self.project_parameters)