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.")
