def _CreateSolver(self, external_model_part=None): """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ ## Structure model part definition main_model_part_name = self.project_parameters["problem_data"][ "model_part_name"].GetString() if self.model.HasModelPart(main_model_part_name): self.main_model_part = self.model[main_model_part_name] self.using_external_model_part = True else: self.main_model_part = KratosMultiphysics.ModelPart( main_model_part_name) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, self.project_parameters["problem_data"] ["domain_size"].GetInt()) self.using_external_model_part = False ## Solver construction import python_solvers_wrapper_structural self.solver = python_solvers_wrapper_structural.CreateSolver( self.main_model_part, self.project_parameters) ## Adds the necessary variables to the model_part only if they don't exist self.solver.AddVariables() if not self.using_external_model_part: ## Read the model - note that SetBufferSize is done here self.solver.ReadModelPart() # TODO move to global instance
def _CreateSolver(self, external_model_part=None): """ Create the Solver (and create and import the ModelPart if it is not passed from outside) """ if external_model_part != None: # This is a temporary solution until the importing of the ModelPart # is removed from the solver (needed e.g. for Optimization) if (type(external_model_part) != KratosMultiphysics.ModelPart): raise Exception( "Input is expected to be provided as a Kratos ModelPart object" ) self.using_external_model_part = True else: self.using_external_model_part = False ## Get echo level and parallel type self.echo_level = self.ProjectParameters["problem_data"][ "echo_level"].GetInt() self.parallel_type = self.ProjectParameters["problem_data"][ "parallel_type"].GetString() # To avoid many prints # TODO leave this? if (self.echo_level == 0): KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.WARNING) ## Import parallel modules if needed if (self.parallel_type == "MPI"): import KratosMultiphysics.mpi as KratosMPI import KratosMultiphysics.MetisApplication as MetisApplication import KratosMultiphysics.TrilinosApplication as TrilinosApplication self.is_printing_rank = (KratosMPI.mpi.rank == 0) else: self.is_printing_rank = True ## Structure model part definition if self.using_external_model_part: self.main_model_part = external_model_part else: main_model_part_name = self.ProjectParameters["problem_data"][ "model_part_name"].GetString() self.main_model_part = KratosMultiphysics.ModelPart( main_model_part_name) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) ## Solver construction import python_solvers_wrapper_structural self.solver = python_solvers_wrapper_structural.CreateSolver( self.main_model_part, self.ProjectParameters) ## Adds the necessary variables to the model_part only if they don't exist self.solver.AddVariables() if not self.using_external_model_part: ## Read the model - note that SetBufferSize is done here self.solver.ReadModelPart() # TODO move to global instance
def _CreateSolver(self): """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ ## Solver construction import python_solvers_wrapper_structural self.solver = python_solvers_wrapper_structural.CreateSolver( self.model, self.project_parameters) ## Adds the necessary variables to the model_part only if they don't exist self.solver.AddVariables() self.solver.ImportModelPart() # TODO move to global instance
if (parallel_type == "MPI"): from KratosMultiphysics.mpi import * from KratosMultiphysics.MetisApplication import * from KratosMultiphysics.TrilinosApplication import * ## Structure model part definition main_model_part_name = ProjectParameters["problem_data"][ "model_part_name"].GetString() main_model_part = ModelPart(main_model_part_name) main_model_part.ProcessInfo.SetValue( DOMAIN_SIZE, ProjectParameters["problem_data"]["domain_size"].GetInt()) ## Solver construction import python_solvers_wrapper_structural solver = python_solvers_wrapper_structural.CreateSolver( main_model_part, ProjectParameters) solver.AddVariables() ## Read the model - note that SetBufferSize is done here solver.ImportModelPart() ## Add AddDofs solver.AddDofs() ## Initialize GiD I/O output_post = ProjectParameters.Has("output_configuration") if (output_post == True): if (parallel_type == "OpenMP"): from gid_output_process import GiDOutputProcess gid_output = GiDOutputProcess(
def __init__(self, ProjectParameters): self.ProjectParameters = ProjectParameters self.main_model_part = KratosMultiphysics.ModelPart(self.ProjectParameters["problem_data"]["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) # Construct the solver (main setting methods are located in the solver_module) import python_solvers_wrapper_structural self.solver = python_solvers_wrapper_structural.CreateSolver(self.main_model_part, self.ProjectParameters) # Add variables (always before importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddVariables() # Read model_part (note: the buffer_size is set here) (restart can be read here) self.solver.ImportModelPart() # Add dofs (always after importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddDofs() self.Model = KratosMultiphysics.Model() self.Model.AddModelPart(self.main_model_part) # Obtain the list of the processes to be applied self.list_of_processes = process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["constraints_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["loads_process_list"]) if (ProjectParameters.Has("list_other_processes") == True): self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["list_other_processes"]) if (ProjectParameters.Has("json_check_process") == True): self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["json_check_process"]) if (ProjectParameters.Has("check_analytic_results_process") == True): self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["check_analytic_results_process"]) if (ProjectParameters.Has("json_output_process") == True): self.list_of_processes += process_factory.KratosProcessFactory(self.Model).ConstructListOfProcesses(self.ProjectParameters["json_output_process"]) for process in self.list_of_processes: process.ExecuteInitialize() # ### START SOLUTION #### self.computing_model_part = self.solver.GetComputingModelPart() # ### Output settings start #### self.problem_path = os.getcwd() self.problem_name = self.ProjectParameters["problem_data"]["problem_name"].GetString() # ### Output settings start #### self.output_post = ProjectParameters.Has("output_configuration") if (self.output_post == True): from gid_output_process import GiDOutputProcess output_settings = ProjectParameters["output_configuration"] self.gid_output = GiDOutputProcess(self.computing_model_part, self.problem_name, output_settings) self.gid_output.ExecuteInitialize() # Sets strategies, builders, linear solvers, schemes and solving info, and fills the buffer self.solver.Initialize() self.solver.SetEchoLevel(0) # Avoid to print anything if (self.output_post == True): self.gid_output.ExecuteBeforeSolutionLoop()
def _CreateSolver(self): """ Create the Solver (and create and import the ModelPart if it is not alread in the model) """ ## Solver construction import python_solvers_wrapper_structural return python_solvers_wrapper_structural.CreateSolver( self.model, self.project_parameters)
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): print("** Calling the partitioned FSI base solver constructor...") # Initial tests start_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: raise("ERROR: Different final time among subdomains!") #TODO: shall obtain the compute_model_part from the MODEL once the object is implemented self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Settings string in JSON format default_settings = KratosMultiphysics.Parameters(""" { "structure_solver_settings": { "solver_type": "structural_mechanics_implicit_dynamic_solver", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "material_import_settings" :{ "materials_filename": "materials.json" }, "echo_level": 0, "time_integration_method": "Implicit", "analysis_type": "nonlinear", "rotation_dofs": false, "pressure_dofs": false, "stabilization_factor": 1.0, "reform_dofs_at_each_step": false, "line_search": false, "compute_reactions": true, "compute_contact_forces": false, "block_builder": false, "move_mesh_flag": true, "solution_type": "Dynamic", "scheme_type": "Newmark", "convergence_criterion": "Residual_criteria", "displacement_relative_tolerance" : 1.0e-3, "displacement_absolute_tolerance" : 1.0e-5, "residual_relative_tolerance" : 1.0e-3, "residual_absolute_tolerance" : 1.0e-5, "max_iteration": 10, "linear_solver_settings":{ "solver_type" : "SuperLUSolver", "max_iteration" : 200, "tolerance" : 1e-7, "scaling" : false, "verbosity" : 1 }, "processes_sub_model_part_list": [""], "problem_domain_sub_model_part_list": ["solid_model_part"] }, "fluid_solver_settings": { "solver_type": "navier_stokes_solver_vmsmonolithic", "model_import_settings": { "input_type": "mdpa", "input_filename": "unknown_name" }, "maximum_iterations": 10, "dynamic_tau" : 0.0, "oss_switch" : 0, "echo_level" : 0, "consider_periodic_conditions" : false, "compute_reactions" : true, "divergence_clearance_steps" : 0, "reform_dofs_at_each_step" : true, "relative_velocity_tolerance" : 1e-3, "absolute_velocity_tolerance" : 1e-5, "relative_pressure_tolerance" : 1e-3, "absolute_pressure_tolerance" : 1e-5, "linear_solver_settings" : { "solver_type" : "AMGCL", "max_iteration" : 200, "tolerance" : 1e-9, "provide_coordinates" : true, "smoother_type" : "ilu0", "krylov_type" : "gmres", "coarsening_type" : "aggregation", "scaling" : true, "verbosity" : 0 }, "volume_model_part_name" : "volume_model_part", "skin_parts" : [""], "no_skin_parts" : [""], "time_stepping" : { "automatic_time_step" : false, "time_step" : 0.1 }, "alpha" :-0.3, "move_mesh_strategy" : 0, "periodic" : "periodic", "move_mesh_flag" : false, "turbulence_model" : "None" }, "coupling_solver_settings": { "coupling_scheme" : "DirichletNeumann", "solver_type" : "partitioned_fsi_solver", "nl_tol" : 1e-5, "nl_max_it" : 50, "solve_mesh_at_each_iteration" : true, "coupling_strategy" : { "solver_type" : "Relaxation", "acceleration_type" : "Aitken", "w_0" : 0.825 }, "mesh_solver" : "mesh_solver_structural_similarity", "mesh_reform_dofs_each_step" : false, "structure_interfaces_list" : [""], "fluid_interfaces_list" : [""] }, "mapper_settings" : [{ "mapper_face" : "Unique", "positive_fluid_interface_submodelpart_name" : "Default_interface_submodelpart_name", "structure_interface_submodelpart_name" : "Default_interface_submodelpart_name" }] } """) # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure print("WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise("ERROR: Different time step among subdomains! No sub-stepping implemented yet.") self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue("structure_solver_settings",project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue("fluid_solver_settings",project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue("coupling_solver_settings",project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue("mapper_settings",project_parameters["coupling_solver_settings"]["mapper_settings"]) # Overwrite the default settings with user-provided parameters self.settings.RecursivelyValidateAndAssignDefaults(default_settings) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"]["nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"]["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings["coupling_solver_settings"]["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"]["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings["coupling_solver_settings"]["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = self.settings["coupling_solver_settings"]["structure_interfaces_list"][0].GetString() coupling_utility_parameters = self.settings["coupling_solver_settings"]["coupling_strategy"] # Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.structure_main_model_part, project_parameters["structure_solver_settings"]) print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) print("* Fluid solver constructed.") # Construct the coupling partitioned strategy import convergence_accelerator_factory self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) print("* Coupling strategy constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") mesh_solver_settings.AddValue("mesh_reform_dofs_each_step",self.settings["coupling_solver_settings"]["mesh_reform_dofs_each_step"]) self.mesh_solver_module = __import__(self.settings["coupling_solver_settings"]["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): print("** Calling the partitioned FSI base solver constructor...") # Initial tests start_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: raise("ERROR: Different final time among subdomains!") self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure print("WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = project_parameters["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise("ERROR: Different time step among subdomains! No sub-stepping implemented yet.") self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters # Note that the defaults check will be performed inside each field solver self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue("structure_solver_settings",project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue("fluid_solver_settings",project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue("coupling_solver_settings",project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue("mapper_settings",project_parameters["coupling_solver_settings"]["mapper_settings"]) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"]["nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"]["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings["coupling_solver_settings"]["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"]["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings["coupling_solver_settings"]["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = self.settings["coupling_solver_settings"]["structure_interfaces_list"][0].GetString() coupling_utility_parameters = self.settings["coupling_solver_settings"]["coupling_strategy"] # Construct the structure solver self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.structure_main_model_part, project_parameters["structure_solver_settings"]) print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) print("* Fluid solver constructed.") # Construct the coupling partitioned strategy import convergence_accelerator_factory self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) print("* Coupling strategy constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") self.mesh_solver_module = __import__(self.settings["coupling_solver_settings"]["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
def __init__(self, structure_main_model_part, fluid_main_model_part, project_parameters): if (KratosMPI.mpi.rank == 0): print( "** Calling the partitioned FSI Trilinos base solver constructor..." ) # Initial tests start_time_structure = project_parameters["structure_solver_settings"][ "problem_data"]["start_time"].GetDouble() start_time_fluid = project_parameters["fluid_solver_settings"][ "problem_data"]["start_time"].GetDouble() end_time_structure = project_parameters["structure_solver_settings"][ "problem_data"]["end_time"].GetDouble() end_time_fluid = project_parameters["fluid_solver_settings"][ "problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: if (KratosMPI.mpi.rank == 0): raise ("ERROR: Different initial time among subdomains!") if end_time_structure != end_time_fluid: if (KratosMPI.mpi.rank == 0): raise ("ERROR: Different final time among subdomains!") self.structure_main_model_part = structure_main_model_part self.fluid_main_model_part = fluid_main_model_part # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = project_parameters["structure_solver_settings"][ "problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (project_parameters["fluid_solver_settings"]["solver_settings"] ["time_stepping"]["automatic_time_step"].GetBool()): project_parameters["fluid_solver_settings"]["solver_settings"][ "time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure if (KratosMPI.mpi.rank == 0): print( "WARNING: Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step." ) else: time_step_fluid = project_parameters["fluid_solver_settings"][ "solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: if (KratosMPI.mpi.rank == 0): raise ( "ERROR: Different time step among subdomains! No sub-stepping implemented yet." ) self.time_step = time_step_fluid # Take the each one of the solvers settings from the ProjectParameters # Note that the defaults check will be performed inside each field solver self.settings = KratosMultiphysics.Parameters("{}") self.settings.AddValue( "structure_solver_settings", project_parameters["structure_solver_settings"]["solver_settings"]) self.settings.AddValue( "fluid_solver_settings", project_parameters["fluid_solver_settings"]["solver_settings"]) self.settings.AddValue( "coupling_solver_settings", project_parameters["coupling_solver_settings"]["solver_settings"]) self.settings.AddValue( "mapper_settings", project_parameters["coupling_solver_settings"]["mapper_settings"]) # Auxiliar variables self.max_nl_it = self.settings["coupling_solver_settings"][ "nl_max_it"].GetInt() self.nl_tol = self.settings["coupling_solver_settings"][ "nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = self.settings[ "coupling_solver_settings"][ "solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = self.settings["coupling_solver_settings"][ "coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = self.settings[ "coupling_solver_settings"]["fluid_interfaces_list"][0].GetString( ) self.structure_interface_submodelpart_name = self.settings[ "coupling_solver_settings"]["structure_interfaces_list"][ 0].GetString() # Construct the structure solver self.structure_model = KratosMultiphysics.Model() structural_solver_settings = project_parameters[ "structure_solver_settings"]["solver_settings"] if not structural_solver_settings.Has("time_stepping"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the time_step, this will be removed!" ) time_stepping_params = KratosMultiphysics.Parameters("{}") time_stepping_params.AddValue( "time_step", project_parameters["problem_data"]["time_step"]) solver_settings.AddValue("time_stepping", time_stepping_params) if not structural_solver_settings.Has("domain_size"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the domain_size, this will be removed!" ) structural_solver_settings.AddEmptyValue("domain_size") structural_solver_settings["domain_size"].SetInt( project_parameters["structure_solver_settings"]["problem_data"] ["domain_size"].GetInt()) if not structural_solver_settings.Has("model_part_name"): KratosMultiphysics.Logger.PrintInfo( "TrilinosPartitionedFSIBaseSolver", "Using the old way to pass the model_part_name, this will be removed!" ) structural_solver_settings.AddEmptyValue("model_part_name") structural_solver_settings["model_part_name"].SetString( project_parameters["structure_solver_settings"]["problem_data"] ["model_part_name"].GetString()) self.structure_solver = python_solvers_wrapper_structural.CreateSolver( self.structure_model, project_parameters["structure_solver_settings"]) if (KratosMPI.mpi.rank == 0): print("* Structure solver constructed.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver( self.fluid_main_model_part, project_parameters["fluid_solver_settings"]) if (KratosMPI.mpi.rank == 0): print("* Fluid solver constructed.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") self.mesh_solver_module = __import__( self.settings["coupling_solver_settings"] ["mesh_solver"].GetString()) self.mesh_solver = self.mesh_solver_module.CreateSolver( self.fluid_solver.main_model_part, mesh_solver_settings) if (KratosMPI.mpi.rank == 0): print("* ALE mesh solver constructed.") print("** Partitioned FSI base solver constructed.")
def __init__(self, ProjectParameters): self.ProjectParameters = ProjectParameters # To avoid many prints echo_level = self.ProjectParameters["problem_data"][ "echo_level"].GetInt() if (echo_level == 0): KratosMultiphysics.Logger.GetDefaultOutput().SetSeverity( KratosMultiphysics.Logger.Severity.WARNING) self.model = KratosMultiphysics.Model() self.main_model_part = KratosMultiphysics.ModelPart( self.ProjectParameters["problem_data"] ["model_part_name"].GetString()) self.main_model_part.ProcessInfo.SetValue( KratosMultiphysics.DOMAIN_SIZE, self.ProjectParameters["problem_data"]["domain_size"].GetInt()) self.problem_type = self.ProjectParameters["problem_data"][ "problem_type"].GetString() self.solve_problem = self.ProjectParameters["problem_data"][ "solve_problem"].GetBool() if (self.problem_type == "fluid" and missing_external_fluid_dependencies == False): ## Solver construction import python_solvers_wrapper_fluid as fluid_wrapper self.solver = fluid_wrapper.CreateSolver(self.model, self.ProjectParameters) elif (self.problem_type == "solid" and missing_external_solid_dependencies == False): self.ProjectParameters["solver_settings"].AddValue( "model_part_name", self.ProjectParameters["problem_data"]["model_part_name"]) self.ProjectParameters["solver_settings"].AddValue( "domain_size", self.ProjectParameters["problem_data"]["domain_size"]) time_stepping_params = KratosMultiphysics.Parameters("{}") time_stepping_params.AddValue( "time_step", self.ProjectParameters["problem_data"]["time_step"]) self.ProjectParameters["solver_settings"].AddValue( "time_stepping", time_stepping_params) params = KratosMultiphysics.Parameters( """{"computing_model_part_name": "Structure"}""") self.ProjectParameters["solver_settings"].AddValue( "computing_model_part_name", params["computing_model_part_name"]) # Construct the solver (main setting methods are located in the solver_module) import python_solvers_wrapper_structural self.solver = python_solvers_wrapper_structural.CreateSolver( self.model, self.ProjectParameters) else: raise NameError( 'Problem type not defined or failing in the import') # Add variables (always before importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddVariables() # Read model_part (note: the buffer_size is set here) (restart can be read here) self.solver.ImportModelPart() self.solver.PrepareModelPart() # Add dofs (always after importing the model part) (it must be integrated in the ImportModelPart) # If we integrate it in the model part we cannot use combined solvers self.solver.AddDofs() # ### Output settings start #### self.problem_path = os.getcwd() self.problem_name = self.ProjectParameters["problem_data"][ "problem_name"].GetString() # ### Output settings start #### self.output_post = ProjectParameters.Has("output_configuration") if (self.output_post == True): from gid_output_process import GiDOutputProcess output_settings = ProjectParameters["output_configuration"] self.gid_output = GiDOutputProcess( self.solver.GetComputingModelPart(), self.problem_name, output_settings) self.gid_output.ExecuteInitialize() # Sets strategies, builders, linear solvers, schemes and solving info, and fills the buffer self.solver.Initialize() self.solver.SetEchoLevel(0) # Avoid to print anything if self.problem_type == "fluid": # Build sub_model_parts or submeshes (rearrange parts for the application of custom processes) # #Get the list of the submodel part in the object Model for i in range(self.ProjectParameters["solver_settings"] ["skin_parts"].size()): skin_part_name = self.ProjectParameters["solver_settings"][ "skin_parts"][i].GetString() self.model.update({ skin_part_name: self.main_model_part.GetSubModelPart(skin_part_name) }) ## Get the list of the initial conditions submodel parts in the object Model for i in range( self.ProjectParameters["initial_conditions_process_list"]. size()): initial_cond_part_name = self.ProjectParameters[ "initial_conditions_process_list"][i]["Parameters"][ "model_part_name"].GetString() self.model.update({ initial_cond_part_name: self.main_model_part.GetSubModelPart( initial_cond_part_name) }) ## Get the gravity submodel part in the object Model for i in range(self.ProjectParameters["gravity"].size()): gravity_part_name = self.ProjectParameters["gravity"][i][ "Parameters"]["model_part_name"].GetString() self.model.update({ gravity_part_name: self.main_model_part.GetSubModelPart(gravity_part_name) }) ## Remeshing processes construction if (self.ProjectParameters.Has("initial_remeshing_process") == True): remeshing_processes = process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["initial_remeshing_process"]) if (ProjectParameters.Has("list_other_processes") == True): remeshing_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"]) ## Remeshing processes initialization print("STARTING ADAPTATIVE LOOP") if (self.ProjectParameters.Has("adaptative_loop") == True): adaptative_loop = ProjectParameters["adaptative_loop"].GetInt() else: adaptative_loop = 1 for n in range(adaptative_loop): print("ADAPTATIVE INTERATION: ", n + 1) for process in reversed(remeshing_processes): process.ExecuteInitialize() process.ExecuteBeforeSolutionLoop() process.ExecuteInitializeSolutionStep() if (self.output_post == True): output_settings = ProjectParameters[ "output_configuration"] gid_output_initial = GiDOutputProcess( self.solver.GetComputingModelPart(), self.problem_name + "_" + str(n + 1), output_settings) gid_output_initial.ExecuteInitialize() gid_output_initial.ExecuteBeforeSolutionLoop() gid_output_initial.ExecuteInitializeSolutionStep() gid_output_initial.ExecuteFinalizeSolutionStep() gid_output_initial.PrintOutput() gid_output_initial.ExecuteFinalize() # Obtain the list of the processes to be applied if self.problem_type == "fluid": self.list_of_processes = process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["gravity"]) self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["initial_conditions_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["boundary_conditions_process_list"]) elif self.problem_type == "solid": self.list_of_processes = process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["constraints_process_list"]) self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["loads_process_list"]) if (self.ProjectParameters.Has("list_other_processes") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["list_other_processes"]) if (self.ProjectParameters.Has("json_check_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["json_check_process"]) if (self.ProjectParameters.Has("json_output_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["json_output_process"]) if (self.ProjectParameters.Has("compare_two_files_check_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["compare_two_files_check_process"]) if (self.ProjectParameters.Has("recursive_remeshing_process") == True): self.list_of_processes += process_factory.KratosProcessFactory( self.model).ConstructListOfProcesses( self.ProjectParameters["recursive_remeshing_process"]) for process in self.list_of_processes: process.ExecuteInitialize() # ### START SOLUTION #### self.computing_model_part = self.solver.GetComputingModelPart() self.root_model_part = self.computing_model_part.GetRootModelPart() if (self.output_post == True): self.gid_output.ExecuteBeforeSolutionLoop()
def RunTestCase(self): StructureSolverSettings = Parameters(""" { "problem_data": { "parallel_type" : "OpenMP" }, "solver_settings" : { "solver_type" : "Dynamic", "echo_level" : 0, "analysis_type" : "linear", "time_integration_method" : "implicit", "scheme_type" : "bossak", "model_import_settings" : { "input_type" : "mdpa", "input_filename" : "test_FSI_emulator_Structural", "input_file_label" : 0 }, "material_import_settings" :{ "materials_filename": "materials_2D.json" }, "line_search" : false, "convergence_criterion" : "Residual_criterion", "displacement_relative_tolerance" : 1e-8, "displacement_absolute_tolerance" : 1e-10, "residual_relative_tolerance" : 1e-8, "residual_absolute_tolerance" : 1e-10, "max_iteration" : 20, "problem_domain_sub_model_part_list" : ["Parts_Solid"], "processes_sub_model_part_list" : ["DISPLACEMENT_Displacement_BC","PointLoad2D_Point_load","StructureInterface2D_Solid_interface"], "rotation_dofs" : false, "linear_solver_settings" : { "solver_type" : "SuperLUSolver", "scaling" : true } } } """) with WorkFolderScope(self.work_folder): self.structure_main_model_part = ModelPart("Structure") self.structure_main_model_part.ProcessInfo.SetValue(DOMAIN_SIZE, 2) # Construct the structure solver import python_solvers_wrapper_structural self.structure_solver = python_solvers_wrapper_structural.CreateSolver( self.structure_main_model_part, StructureSolverSettings) self.structure_solver.AddVariables() self.structure_solver.ImportModelPart() self.structure_solver.AddDofs() self.SetStructureBoundaryConditions() self.structure_solver.Initialize() self.coupling_utility.Initialize() residual_size = self.GetInterfaceProblemSize( ) * 2 # Interface DOFs number times PROBLEM_SIZE self.iteration_value = Vector( residual_size ) # Interface solution guess (it might be velocity or fluxes depending on the type of coupling) for i in range(0, residual_size): self.iteration_value[i] = 0.0 step = 0 time = 0.0 while (time <= self.end_time): time = time + self.Dt step = step + 1 self.structure_solver.main_model_part.ProcessInfo.SetValue( TIME_STEPS, step) self.structure_main_model_part.CloneTimeStep(time) self.PointLoadUpdate() self.structure_solver.InitializeSolutionStep() self.structure_solver.Predict() self.coupling_utility.InitializeSolutionStep() for nl_it in range(1, self.max_nl_it + 1): self.coupling_utility.InitializeNonLinearIteration() # Residual computation disp_residual = self.ComputeDirichletNeumannResidual() nl_res_norm = UblasSparseSpace().TwoNorm(disp_residual) # Check convergence if nl_res_norm < self.nl_tol: break else: # If convergence is not achieved, perform the correction of the prediction self.coupling_utility.UpdateSolution( disp_residual, self.iteration_value) self.coupling_utility.FinalizeNonLinearIteration() self.structure_solver.FinalizeSolutionStep() self.coupling_utility.FinalizeSolutionStep() # Unitcest convergence criterion check self.assertLess(nl_res_norm, self.nl_tol)
def __init__(self, model, project_parameters): super(PartitionedFSIBaseSolver,self).__init__(model, project_parameters) # Initial tests start_time_structure = self.settings["structure_solver_settings"]["problem_data"]["start_time"].GetDouble() start_time_fluid = self.settings["fluid_solver_settings"]["problem_data"]["start_time"].GetDouble() end_time_structure = self.settings["structure_solver_settings"]["problem_data"]["end_time"].GetDouble() end_time_fluid = self.settings["fluid_solver_settings"]["problem_data"]["end_time"].GetDouble() if start_time_structure != start_time_fluid: raise Exception('Different initial time among subdomains.') if end_time_structure != end_time_fluid: raise Exception('Different final time among subdomains.') solver_settings = self.settings["fluid_solver_settings"]["solver_settings"] problem_data = self.settings["fluid_solver_settings"]["problem_data"] if solver_settings.Has("model_part_name"): self.fluid_model_part_name = solver_settings["model_part_name"].GetString() elif problem_data.Has("model_part_name"): self.fluid_model_part_name = problem_data["model_part_name"].GetString() # Backwards compatibility: copy the name to the solver section so that the fluid solver can read it solver_settings.AddEmptyValue("model_part_name") solver_settings["model_part_name"].SetString(self.fluid_model_part_name) # Backwards compatibility: copy the domain size to the solver section if not solver_settings.Has("domain_size"): solver_settings.AddEmptyValue("domain_size") solver_settings["domain_size"].SetInt(problem_data["domain_size"].GetInt()) # Time stepping checks (no sub-stepping between subdomains has been implemented yed) time_step_structure = self.settings["structure_solver_settings"]["problem_data"]["time_step"].GetDouble() # If automatic time stepping has been selected in the fluid domain, deactivate it and use the structure time step if (self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].GetBool()): self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["automatic_time_step"].SetBool(False) time_step_fluid = time_step_structure self._PrintWarningOnRankZero("::[PartitionedFSIBaseSolver]::", "Automatic fluid time stepping cannot be used. Setting structure time step as fluid time step.") else: time_step_fluid = self.settings["fluid_solver_settings"]["solver_settings"]["time_stepping"]["time_step"].GetDouble() if time_step_structure != time_step_fluid: raise Exception('Different time step among subdomains! No sub-stepping implemented yet.') self.time_step = time_step_fluid # Auxiliar variables coupling_solver_settings = self.settings["coupling_solver_settings"]["solver_settings"] self.max_nl_it = coupling_solver_settings["nl_max_it"].GetInt() self.nl_tol = coupling_solver_settings["nl_tol"].GetDouble() self.solve_mesh_at_each_iteration = coupling_solver_settings["solve_mesh_at_each_iteration"].GetBool() self.coupling_algorithm = coupling_solver_settings["coupling_scheme"].GetString() self.fluid_interface_submodelpart_name = coupling_solver_settings["fluid_interfaces_list"][0].GetString() self.structure_interface_submodelpart_name = coupling_solver_settings["structure_interfaces_list"][0].GetString() coupling_utility_parameters = coupling_solver_settings["coupling_strategy"] # Construct the structure solver structural_solver_settings = self.settings["structure_solver_settings"]["solver_settings"] if not structural_solver_settings.Has("time_stepping"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the time_step, this will be removed!") time_stepping_params = KratosMultiphysics.Parameters("{}") time_stepping_params.AddValue("time_step", self.settings["structure_solver_settings"]["problem_data"]["time_step"]) structural_solver_settings.AddValue("time_stepping", time_stepping_params) if not structural_solver_settings.Has("domain_size"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the domain_size, this will be removed!") structural_solver_settings.AddEmptyValue("domain_size") structural_solver_settings["domain_size"].SetInt(self.settings["structure_solver_settings"]["problem_data"]["domain_size"].GetInt()) if not structural_solver_settings.Has("model_part_name"): self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Using the old way to pass the model_part_name, this will be removed!") structural_solver_settings.AddEmptyValue("model_part_name") structural_solver_settings["model_part_name"].SetString(self.settings["structure_solver_settings"]["problem_data"]["model_part_name"].GetString()) self.structure_solver = python_solvers_wrapper_structural.CreateSolver(self.model, self.settings["structure_solver_settings"]) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Structure solver construction finished.") # Construct the fluid solver self.fluid_solver = python_solvers_wrapper_fluid.CreateSolver(self.model, self.settings["fluid_solver_settings"]) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Fluid solver construction finished.") # Construct the coupling partitioned strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator(coupling_utility_parameters) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Coupling strategy construction finished.") # Construct the ALE mesh solver mesh_solver_settings = KratosMultiphysics.Parameters("{}") mesh_solver_settings.AddEmptyValue("problem_data") mesh_solver_settings.AddEmptyValue("solver_settings") parallel_type = KratosMultiphysics.Parameters('''{"parallel_type" : ""}''') parallel_type["parallel_type"].SetString(self.settings["fluid_solver_settings"]["problem_data"]["parallel_type"].GetString()) mesh_solver_type = KratosMultiphysics.Parameters('''{"solver_type" : ""}''') mesh_solver_type["solver_type"].SetString(self.settings["coupling_solver_settings"]["solver_settings"]["mesh_solver"].GetString()) mesh_solver_settings["problem_data"] = parallel_type mesh_solver_settings["solver_settings"] = mesh_solver_type #TODO: UPDATE TO MODEL ONCE MESH MOVING APPLICATION SUPPORTS IT self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolver(self.fluid_solver.main_model_part, mesh_solver_settings) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "ALE mesh solver construction finished.") self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Partitioned FSI base solver construction finished.")