def __init__(self, model, solver_settings, parallelism):
self._validate_settings_in_baseclass=True # To be removed eventually
super().__init__(model, solver_settings)
self.start_fluid_solution_time = self.settings["start_fluid_solution_time"].GetDouble()
self.parallelism = parallelism
fluid_solver_settings = self.settings["fluid_solver_settings"]
mesh_motion_solver_settings = self.settings["mesh_motion_solver_settings"]
fluid_model_part_name = fluid_solver_settings["model_part_name"].GetString()
if not self.model.HasModelPart(fluid_model_part_name):
model.CreateModelPart(fluid_model_part_name)
# Derived class decides if the reactions should be computed or not
self._ManipulateFluidSolverSettingsForReactionsComputation(fluid_solver_settings)
# Creating the fluid solver
self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings, parallelism)
# Creating the mesh-motion solver
if not mesh_motion_solver_settings.Has("echo_level"):
mesh_motion_solver_settings.AddValue("echo_level", self.settings["echo_level"])
# Making sure the settings are consistent btw fluid and mesh-motion
if mesh_motion_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_motion_solver_settings["model_part_name"].GetString():
err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n'
err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts'
raise Exception(err_msg)
else:
mesh_motion_solver_settings.AddValue("model_part_name", fluid_solver_settings["model_part_name"])
domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_motion_solver_settings.Has("domain_size"):
mesh_motion_domain_size = mesh_motion_solver_settings["domain_size"].GetInt()
if not domain_size == mesh_motion_domain_size:
raise Exception('Fluid- and Mesh-Solver have to use the same "domain_size"!')
else:
mesh_motion_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"])
# Derived class decides if the mesh velocities should be computed or not
self._ManipulateMeshMotionSolverSettingsForMeshVelocityComputation(fluid_solver_settings, mesh_motion_solver_settings)
# Constructing the mesh-solver with the entire mesh
# if no submodelparts are specified then this is used for the computation of the mesh-motion
# otherwise it only adds the dofs and the variables (to the entire ModelPart!)
self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters(
model, mesh_motion_solver_settings, parallelism)
# Getting the min_buffer_size from both solvers
# and assigning it to the fluid_solver, bcs this one handles the model_part
self.fluid_solver.min_buffer_size = max(
self.fluid_solver.GetMinimumBufferSize(),
self.mesh_motion_solver_full_mesh.GetMinimumBufferSize())
KM.Logger.PrintInfo("::[AleFluidSolver]::", "Construction finished")
def Initialize(self):
# Saving the ALE-interface-parts for later
# this can only be done AFTER reading the ModelPart
main_model_part_name = self.settings["fluid_solver_settings"][
"model_part_name"].GetString()
ale_boundary_parts_params = self.settings["ale_boundary_parts"]
self.ale_boundary_parts = []
for i_name in range(ale_boundary_parts_params.size()):
sub_model_part_name = ale_boundary_parts_params[i_name].GetString()
full_model_part_name = main_model_part_name + "." + sub_model_part_name
self.ale_boundary_parts.append(self.model[full_model_part_name])
mesh_motion_parts_params = self.settings["mesh_motion_parts"]
self.mesh_motion_solvers = []
if mesh_motion_parts_params.size() == 0:
# the entire Fluid-ModelPart is used in the Mesh-Solver
self.mesh_motion_solvers.append(self.mesh_motion_solver_full_mesh)
else:
# SubModelParts of the Fluid-ModelPart are used in the Mesh-Solver
# each SubModelPart has its own mesh-solver
# Note that these solvers do NOT need to call AddVariables and AddDofs
# since this is done already for the MainModelPart
for i_name in range(mesh_motion_parts_params.size()):
sub_model_part_name = mesh_motion_parts_params[
i_name].GetString()
if sub_model_part_name == main_model_part_name:
err_msg = 'The MainModelPart cannot be used as one of the Sub-Mesh-Solvers!\n'
err_msg += 'Remove "mesh_motion_parts" for specifying mesh-motion on the MainModelPart'
raise Exception(err_msg)
full_model_part_name = main_model_part_name + "." + sub_model_part_name
sub_mesh_solver_settings = self.settings[
"mesh_motion_solver_settings"].Clone()
sub_mesh_solver_settings["model_part_name"].SetString(
full_model_part_name)
self.mesh_motion_solvers.append(
mesh_mothion_solvers_wrapper.CreateSolverByParameters(
self.model, sub_mesh_solver_settings,
self.parallelism))
for mesh_solver in self.mesh_motion_solvers:
mesh_solver.Initialize()
self.fluid_solver.Initialize()
if self.is_printing_rank:
KM.Logger.PrintInfo("::[AleFluidSolver]::",
"Finished initialization")
def __init__(self, model, project_parameters):
# Validate settings
project_parameters = self._ValidateSettings(project_parameters)
# Call the base Python solver constructor
super(PartitionedFSIBaseSolver, self).__init__(model,
project_parameters)
# Auxiliar variables
self.parallel_type = self.settings["parallel_type"].GetString()
coupling_settings = self.settings["coupling_settings"]
self.max_nl_it = coupling_settings["nl_max_it"].GetInt()
self.nl_tol = coupling_settings["nl_tol"].GetDouble()
self.solve_mesh_at_each_iteration = coupling_settings[
"solve_mesh_at_each_iteration"].GetBool()
self.fluid_interface_submodelpart_name = coupling_settings[
"fluid_interfaces_list"][0].GetString()
self.structure_interface_submodelpart_name = coupling_settings[
"structure_interfaces_list"][0].GetString()
# Construct the structure solver
self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters(
self.model, self.settings["structure_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"Structure solver construction finished.")
# Construct the fluid solver
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"Fluid solver construction finished.")
# Construct the ALE mesh solver
self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters(
self.model, self.settings["mesh_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"ALE mesh solver construction finished.")
self._PrintInfoOnRankZero(
"::[PartitionedFSIBaseSolver]::",
"Partitioned FSI base solver construction finished.")
def __init__(self, model, solver_settings, parallelism):
default_settings = KM.Parameters("""{
"solver_type" : "ale_fluid",
"echo_level" : 0,
"ale_boundary_parts" : [ ],
"mesh_motion_parts" : [ ],
"fluid_solver_settings" : { },
"mesh_motion_solver_settings" : { },
"mesh_velocity_calculation" : { }
}""")
# cannot recursively validate because validation of fluid- and
# mesh-motion-settings is done in corresponding solvers
solver_settings.ValidateAndAssignDefaults(default_settings)
super(AleFluidSolver, self).__init__(model, solver_settings)
self.parallelism = parallelism
fluid_solver_settings = self.settings["fluid_solver_settings"]
mesh_motion_solver_settings = self.settings[
"mesh_motion_solver_settings"]
fluid_model_part_name = fluid_solver_settings[
"model_part_name"].GetString()
if not self.model.HasModelPart(fluid_model_part_name):
model.CreateModelPart(fluid_model_part_name)
## Checking if reactions are being computed in the fluid
if fluid_solver_settings.Has("compute_reactions"):
if fluid_solver_settings["compute_reactions"].GetBool() == False:
fluid_solver_settings["compute_reactions"].SetBool(True)
warn_msg = '"compute_reactions" is switched off for the fluid-solver, '
warn_msg += 'switching it on!'
KM.Logger.PrintWarning("::[AleFluidSolver]::", warn_msg)
else:
fluid_solver_settings.AddEmptyValue("compute_reactions").SetBool(
True)
info_msg = 'Setting "compute_reactions" to true for the fluid-solver'
KM.Logger.PrintInfo("::[AleFluidSolver]::", info_msg)
## Creating the fluid solver
self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings,
parallelism)
self.is_printing_rank = self.fluid_solver._IsPrintingRank()
# Doing this after the Fluid-solver-settings have been validated to access the settings
self._SelectMeshVelocityCalculationSettings()
self.__InitializeMeshVelocityComputation()
## Creating the mesh-motion solver
if not mesh_motion_solver_settings.Has("echo_level"):
mesh_motion_solver_settings.AddValue("echo_level",
self.settings["echo_level"])
# Making sure the settings are consistent btw fluid and mesh-motion
if mesh_motion_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_motion_solver_settings[
"model_part_name"].GetString():
err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n'
err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts'
raise Exception(err_msg)
else:
mesh_motion_solver_settings.AddValue(
"model_part_name", fluid_solver_settings["model_part_name"])
domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_motion_solver_settings.Has("domain_size"):
mesh_motion_domain_size = mesh_motion_solver_settings[
"domain_size"].GetInt()
if not domain_size == mesh_motion_domain_size:
raise Exception(
'Fluid- and Mesh-Solver have to use the same "domain_size"!'
)
else:
mesh_motion_solver_settings.AddValue(
"domain_size", fluid_solver_settings["domain_size"])
# TODO remove this once the mesh-vel-computation is removed from the mesh-solver!
# We use the new utility, therefore explicitly setting it to false!
if mesh_motion_solver_settings.Has("calculate_mesh_velocities"):
mesh_motion_solver_settings["calculate_mesh_velocities"].SetBool(
False)
else:
mesh_motion_solver_settings.AddEmptyValue(
"calculate_mesh_velocities").SetBool(False)
# Constructing the mesh-solver with the entire mesh
# if no submodelparts are specified then this is used for the computation of the mesh-motion
# otherwise it only adds the dofs and the variables (to the entire ModelPart!)
self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters(
model, mesh_motion_solver_settings, parallelism)
# Getting the min_buffer_size from both solvers
# and assigning it to the fluid_solver, bcs this one handles the model_part
self.fluid_solver.min_buffer_size = max([
self.fluid_solver.GetMinimumBufferSize(),
self.mesh_motion_solver_full_mesh.GetMinimumBufferSize(),
KM.GetMinimumBufferSize(self.time_int_helper)
])
if self.is_printing_rank:
KM.Logger.PrintInfo("::[AleFluidSolver]::",
"Construction finished")
def __init__(self, model, project_parameters):
# TODO: Remove this as soon as the MPCs are implemented in MPI
# This has to be done prior to the defaults check to avoid the structural solver to throw an error in MPI
if not project_parameters["structure_solver_settings"].Has(
"multi_point_constraints_used"):
project_parameters["structure_solver_settings"].AddEmptyValue(
"multi_point_constraints_used")
project_parameters["structure_solver_settings"][
"multi_point_constraints_used"].SetBool(False)
# Call the base Python solver constructor
# Note that default settings in GetDefaultParameters() are validated in here
super().__init__(model, project_parameters)
# Auxiliar variables
self.parallel_type = self.settings["parallel_type"].GetString()
coupling_settings = self.settings["coupling_settings"]
self.max_nl_it = coupling_settings["nl_max_it"].GetInt()
self.nl_tol = coupling_settings["nl_tol"].GetDouble()
self.solve_mesh_at_each_iteration = coupling_settings[
"solve_mesh_at_each_iteration"].GetBool()
self.fluid_interface_submodelpart_name = coupling_settings[
"fluid_interfaces_list"][0].GetString()
self.structure_interface_submodelpart_name = coupling_settings[
"structure_interfaces_list"][0].GetString()
## Construct the structure solver
self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters(
self.model, self.settings["structure_solver_settings"],
self.parallel_type)
KratosMultiphysics.Logger.PrintInfo(
"::[PartitionedFSIBaseSolver]::",
"Structure solver construction finished.")
## Construct the fluid solver
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_solver_settings"],
self.parallel_type)
KratosMultiphysics.Logger.PrintInfo(
"::[PartitionedFSIBaseSolver]::",
"Fluid solver construction finished.")
## Check the ALE settings before the mesh solver construction
mesh_solver_settings = self.settings["mesh_solver_settings"]
fluid_solver_settings = self.settings["fluid_solver_settings"]
# Check that the ALE and the fluid are the same model part
fluid_model_part_name = fluid_solver_settings[
"model_part_name"].GetString()
if mesh_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_solver_settings[
"model_part_name"].GetString():
err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n'
raise Exception(err_msg)
else:
mesh_solver_settings.AddValue(
"model_part_name", fluid_solver_settings["model_part_name"])
# Ensure that the fluid domain is not imported twice
if mesh_solver_settings.Has("model_import_settings"):
if mesh_solver_settings["model_import_settings"].Has("input_type"):
if not mesh_solver_settings["model_import_settings"][
"input_type"].GetString() == "use_input_model_part":
mesh_solver_settings["model_import_settings"][
"input_type"].SetString("use_input_model_part")
else:
mesh_solver_settings["model_import_settings"].AddEmptyValue(
"input_type").SetString("use_input_model_part")
else:
mesh_solver_settings.AddEmptyValue(
"model_import_settings").AddEmptyValue("input_type").SetString(
"use_input_model_part")
# Check that the ALE and the fluid have the sime time scheme
fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString()
if mesh_solver_settings.Has("mesh_velocity_calculation"):
if mesh_solver_settings["mesh_velocity_calculation"].Has(
"time_scheme"):
if not fluid_time_scheme == mesh_solver_settings[
"mesh_velocity_calculation"]["time_scheme"].GetString(
):
err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n'
raise Exception(err_msg)
else:
mesh_solver_settings["mesh_velocity_calculation"].AddValue(
"time_scheme", fluid_solver_settings["time_scheme"])
else:
mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation")
mesh_solver_settings["mesh_velocity_calculation"].AddValue(
"time_scheme", fluid_solver_settings["time_scheme"])
# Check domain size
fluid_domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_solver_settings.Has("domain_size"):
if not fluid_domain_size == mesh_solver_settings[
"domain_size"].GetInt():
raise Exception(
'Fluid and mesh solver have different "domain_size"!')
else:
mesh_solver_settings.AddValue("domain_size",
fluid_solver_settings["domain_size"])
# Ensure that the MESH_VELOCITY is computed
if mesh_solver_settings.Has("calculate_mesh_velocity"):
if not mesh_solver_settings["calculate_mesh_velocity"].GetBool():
mesh_solver_settings.SetValue("calculate_mesh_velocity", True)
KratosMultiphysics.Logger.PrintWarning(
"",
"Mesh velocity calculation was deactivated. Switching \"calculate_mesh_velocity\" on"
)
else:
mesh_solver_settings.AddEmptyValue(
"calculate_mesh_velocity").SetBool(True)
## Construct the ALE mesh solver
self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters(
self.model, self.settings["mesh_solver_settings"],
self.parallel_type)
KratosMultiphysics.Logger.PrintInfo(
"::[PartitionedFSIBaseSolver]::",
"ALE mesh solver construction finished.")
KratosMultiphysics.Logger.PrintInfo(
"::[PartitionedFSIBaseSolver]::",
"Partitioned FSI base solver construction finished.")
def __init__(self, model, solver_settings, parallelism):
self._validate_settings_in_baseclass = True # To be removed eventually
super(AleFluidSolver, self).__init__(model, solver_settings)
self.start_fluid_solution_time = self.settings[
"start_fluid_solution_time"].GetDouble()
self.parallelism = parallelism
fluid_solver_settings = self.settings["fluid_solver_settings"]
mesh_motion_solver_settings = self.settings[
"mesh_motion_solver_settings"]
fluid_model_part_name = fluid_solver_settings[
"model_part_name"].GetString()
if not self.model.HasModelPart(fluid_model_part_name):
model.CreateModelPart(fluid_model_part_name)
## Checking if reactions are being computed in the fluid
if fluid_solver_settings.Has("compute_reactions"):
if fluid_solver_settings["compute_reactions"].GetBool() == False:
fluid_solver_settings["compute_reactions"].SetBool(True)
warn_msg = '"compute_reactions" is switched off for the fluid-solver, '
warn_msg += 'switching it on!'
KM.Logger.PrintWarning("::[AleFluidSolver]::", warn_msg)
else:
fluid_solver_settings.AddEmptyValue("compute_reactions").SetBool(
True)
info_msg = 'Setting "compute_reactions" to true for the fluid-solver'
KM.Logger.PrintInfo("::[AleFluidSolver]::", info_msg)
## Creating the fluid solver
self.fluid_solver = self._CreateFluidSolver(fluid_solver_settings,
parallelism)
# Doing this after the Fluid-solver-settings have been validated to access the settings
self._SelectMeshVelocityCalculationSettings()
self.__InitializeMeshVelocityComputation()
## Creating the mesh-motion solver
if not mesh_motion_solver_settings.Has("echo_level"):
mesh_motion_solver_settings.AddValue("echo_level",
self.settings["echo_level"])
# Making sure the settings are consistent btw fluid and mesh-motion
if mesh_motion_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_motion_solver_settings[
"model_part_name"].GetString():
err_msg = 'Fluid- and Mesh-Solver have to use the same MainModelPart ("model_part_name")!\n'
err_msg += 'Use "mesh_motion_parts" for specifying mesh-motion on sub-model-parts'
raise Exception(err_msg)
else:
mesh_motion_solver_settings.AddValue(
"model_part_name", fluid_solver_settings["model_part_name"])
domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_motion_solver_settings.Has("domain_size"):
mesh_motion_domain_size = mesh_motion_solver_settings[
"domain_size"].GetInt()
if not domain_size == mesh_motion_domain_size:
raise Exception(
'Fluid- and Mesh-Solver have to use the same "domain_size"!'
)
else:
mesh_motion_solver_settings.AddValue(
"domain_size", fluid_solver_settings["domain_size"])
# Constructing the mesh-solver with the entire mesh
# if no submodelparts are specified then this is used for the computation of the mesh-motion
# otherwise it only adds the dofs and the variables (to the entire ModelPart!)
self.mesh_motion_solver_full_mesh = mesh_mothion_solvers_wrapper.CreateSolverByParameters(
model, mesh_motion_solver_settings, parallelism)
# Getting the min_buffer_size from both solvers
# and assigning it to the fluid_solver, bcs this one handles the model_part
self.fluid_solver.min_buffer_size = max([
self.fluid_solver.GetMinimumBufferSize(),
self.mesh_motion_solver_full_mesh.GetMinimumBufferSize(),
KM.TimeDiscretization.GetMinimumBufferSize(self.time_int_helper)
])
KM.Logger.PrintInfo("::[AleFluidSolver]::", "Construction finished")
def __init__(self, model, project_parameters):
# Validate settings
project_parameters = self._ValidateSettings(project_parameters)
# Call the base Python solver constructor
super(PartitionedFSIBaseSolver, self).__init__(model,
project_parameters)
# Auxiliar variables
self.parallel_type = self.settings["parallel_type"].GetString()
coupling_settings = self.settings["coupling_settings"]
self.max_nl_it = coupling_settings["nl_max_it"].GetInt()
self.nl_tol = coupling_settings["nl_tol"].GetDouble()
self.solve_mesh_at_each_iteration = coupling_settings[
"solve_mesh_at_each_iteration"].GetBool()
self.fluid_interface_submodelpart_name = coupling_settings[
"fluid_interfaces_list"][0].GetString()
self.structure_interface_submodelpart_name = coupling_settings[
"structure_interfaces_list"][0].GetString()
## Construct the structure solver
self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters(
self.model, self.settings["structure_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"Structure solver construction finished.")
## Construct the fluid solver
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"Fluid solver construction finished.")
## Check the ALE settings before the mesh solver construction
mesh_solver_settings = self.settings["mesh_solver_settings"]
fluid_solver_settings = self.settings["fluid_solver_settings"]
# Check that the ALE and the fluid are the same model part
fluid_model_part_name = fluid_solver_settings[
"model_part_name"].GetString()
if mesh_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_solver_settings[
"model_part_name"].GetString():
err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n'
raise Exception(err_msg)
else:
mesh_solver_settings.AddValue(
"model_part_name", fluid_solver_settings["model_part_name"])
# Check that the ALE and the fluid have the sime time scheme
fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString()
if mesh_solver_settings.Has("mesh_velocity_calculation"):
if mesh_solver_settings["mesh_velocity_calculation"].Has(
"time_scheme"):
if not fluid_time_scheme == mesh_solver_settings[
"mesh_velocity_calculation"]["time_scheme"].GetString(
):
err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n'
raise Exception(err_msg)
else:
mesh_solver_settings["mesh_velocity_calculation"].AddValue(
"time_scheme", fluid_solver_settings["time_scheme"])
else:
mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation")
mesh_solver_settings["mesh_velocity_calculation"].AddValue(
"time_scheme", fluid_solver_settings["time_scheme"])
# Check domain size
fluid_domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_solver_settings.Has("domain_size"):
if not fluid_domain_size == mesh_solver_settings[
"domain_size"].GetInt():
raise Exception(
'Fluid and mesh solver have different "domain_size"!')
else:
mesh_solver_settings.AddValue("domain_size",
fluid_solver_settings["domain_size"])
# Ensure that the MESH_VELOCITY is computed
if mesh_solver_settings.Has("calculate_mesh_velocity"):
if not mesh_solver_settings["calculate_mesh_velocity"].GetBool():
mesh_solver_settings.SetValue("calculate_mesh_velocity", True)
self._PrintWarningOnRankZero(
"",
"Mesh velocity calculation was desactivated. Switching \"calculate_mesh_velocity\" on"
)
else:
mesh_solver_settings.AddEmptyValue(
"calculate_mesh_velocity").SetBool(True)
## Construct the ALE mesh solver
self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters(
self.model, self.settings["mesh_solver_settings"],
self.parallel_type)
self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::",
"ALE mesh solver construction finished.")
self._PrintInfoOnRankZero(
"::[PartitionedFSIBaseSolver]::",
"Partitioned FSI base solver construction finished.")
def _AuxiliaryInitOperations(self):
# Auxiliar variables
self.parallel_type = self.settings["parallel_type"].GetString()
coupling_settings = self.settings["coupling_settings"]
self.max_nl_it = coupling_settings["nl_max_it"].GetInt()
self.nl_tol = coupling_settings["nl_tol"].GetDouble()
self.solve_mesh_at_each_iteration = coupling_settings["solve_mesh_at_each_iteration"].GetBool()
## Save the FSI interfaces information in a dictionary
mappers_settings = self.settings["coupling_settings"]["mapper_settings"]
self.interfaces_dict = {}
self.interfaces_dict['structure'] = coupling_settings["structure_interfaces_list"][0].GetString()
if mappers_settings.size() == 1:
self.double_faced_structure = False
self.interfaces_dict['fluid_positive'] = mappers_settings[0]["fluid_interface_submodelpart_name"].GetString()
self.interfaces_dict['fluid_negative'] = None
elif mappers_settings.size() == 2:
self.double_faced_structure = True
for mapper_id in range(2):
if (mappers_settings[mapper_id]["mapper_face"].GetString() == "Positive"):
self.interfaces_dict['fluid_positive'] = mappers_settings[mapper_id]["fluid_interface_submodelpart_name"].GetString()
elif (mappers_settings[mapper_id]["mapper_face"].GetString() == "Negative"):
self.interfaces_dict['fluid_negative'] = mappers_settings[mapper_id]["fluid_interface_submodelpart_name"].GetString()
else:
err_msg = "The mapper face is not \'Positve\' nor \'Negative\'."
raise Exception(err_msg)
else:
err_msg = "Case with more than 2 mappers has not been implemented yet.\n"
err_msg += "Please, in case you are using single faced immersed bodies, set the skin entities in a unique submodelpart.\n"
err_msg += "In case you are considering double faced immersed bodies (shells or membranes), set all the positive faces in a unique submodelpart and all the negative ones in another submodelpart."
raise Exception(err_msg)
## Construct the structure solver
self.structure_solver = python_solvers_wrapper_structural.CreateSolverByParameters(self.model, self.settings["structure_solver_settings"], self.parallel_type)
KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "Structure solver construction finished.")
## Construct the fluid solver
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(self.model, self.settings["fluid_solver_settings"], self.parallel_type)
KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "Fluid solver construction finished.")
## Check the ALE settings before the mesh solver construction
mesh_solver_settings = self.settings["mesh_solver_settings"]
fluid_solver_settings = self.settings["fluid_solver_settings"]
# Check that the ALE and the fluid are the same model part
fluid_model_part_name = fluid_solver_settings["model_part_name"].GetString()
if mesh_solver_settings.Has("model_part_name"):
if not fluid_model_part_name == mesh_solver_settings["model_part_name"].GetString():
err_msg = 'Fluid and mesh solver have to use the same MainModelPart ("model_part_name")!\n'
raise Exception(err_msg)
else:
mesh_solver_settings.AddValue("model_part_name", fluid_solver_settings["model_part_name"])
# Ensure that the fluid domain is not imported twice
if mesh_solver_settings.Has("model_import_settings"):
if mesh_solver_settings["model_import_settings"].Has("input_type"):
if not mesh_solver_settings["model_import_settings"]["input_type"].GetString() == "use_input_model_part":
mesh_solver_settings["model_import_settings"]["input_type"].SetString("use_input_model_part")
else:
mesh_solver_settings["model_import_settings"].AddEmptyValue("input_type").SetString("use_input_model_part")
else:
mesh_solver_settings.AddEmptyValue("model_import_settings").AddEmptyValue("input_type").SetString("use_input_model_part")
# Check that the ALE and the fluid have the sime time scheme
if fluid_solver_settings.Has("time_scheme"):
fluid_time_scheme = fluid_solver_settings["time_scheme"].GetString()
if mesh_solver_settings.Has("mesh_velocity_calculation"):
if mesh_solver_settings["mesh_velocity_calculation"].Has("time_scheme"):
if not fluid_time_scheme == mesh_solver_settings["mesh_velocity_calculation"]["time_scheme"].GetString():
err_msg = 'Fluid and mesh solver require to use the same time scheme ("time_scheme") for consistency!\n'
raise Exception(err_msg)
else:
mesh_solver_settings["mesh_velocity_calculation"].AddValue("time_scheme", fluid_solver_settings["time_scheme"])
else:
mesh_solver_settings.AddEmptyValue("mesh_velocity_calculation")
mesh_solver_settings["mesh_velocity_calculation"].AddValue("time_scheme", fluid_solver_settings["time_scheme"])
# Check domain size
fluid_domain_size = fluid_solver_settings["domain_size"].GetInt()
if mesh_solver_settings.Has("domain_size"):
if not fluid_domain_size == mesh_solver_settings["domain_size"].GetInt():
raise Exception('Fluid and mesh solver have different "domain_size"!')
else:
mesh_solver_settings.AddValue("domain_size", fluid_solver_settings["domain_size"])
# Ensure that the MESH_VELOCITY is computed
if mesh_solver_settings.Has("calculate_mesh_velocity"):
if not mesh_solver_settings["calculate_mesh_velocity"].GetBool():
mesh_solver_settings.SetValue("calculate_mesh_velocity", True)
KratosMultiphysics.Logger.PrintWarning("","Mesh velocity calculation was deactivated. Switching \"calculate_mesh_velocity\" on")
else:
mesh_solver_settings.AddEmptyValue("calculate_mesh_velocity").SetBool(True)
## Construct the ALE mesh solver
self.mesh_solver = python_solvers_wrapper_mesh_motion.CreateSolverByParameters(self.model, self.settings["mesh_solver_settings"], self.parallel_type)
KratosMultiphysics.Logger.PrintInfo("PartitionedFSIBaseSolver", "ALE mesh solver construction finished.")
