def __init__(self, model, project_parameters):
# Validate settings
project_parameters = self._ValidateSettings(project_parameters)
# Call the base Python solver constructor
super(PartitionedEmbeddedFSIBaseSolver,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.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('PartitionedEmbeddedFSIBaseSolver', '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.level_set_type = self.settings["fluid_solver_settings"]["formulation"]["level_set_type"].GetString()
# First call to create the embedded intersections model part
self.__GetEmbedddedSkinUtilityModelPart()
KratosMultiphysics.Logger.PrintInfo('PartitionedEmbeddedFSIBaseSolver', 'Fluid solver construction finished')
KratosMultiphysics.Logger.PrintInfo('PartitionedEmbeddedFSIBaseSolver', 'Partitioned embedded FSI base solver construction finished')
def __init__(self, model, custom_settings):
super(CoupledFluidThermalSolver, self).__init__(model, custom_settings)
## Get domain size
self.domain_size = self.settings["domain_size"].GetInt()
from KratosMultiphysics.FluidDynamicsApplication import python_solvers_wrapper_fluid
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(self.model, self.settings["fluid_solver_settings"],"OpenMP")
from KratosMultiphysics.ConvectionDiffusionApplication import python_solvers_wrapper_convection_diffusion
self.thermal_solver = python_solvers_wrapper_convection_diffusion.CreateSolverByParameters(self.model,self.settings["thermal_solver_settings"],"OpenMP")
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
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.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(
'PartitionedEmbeddedFSIBaseSolver',
'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.level_set_type = self.settings["fluid_solver_settings"][
"formulation"]["level_set_type"].GetString()
# First call to create the embedded intersections model part
self.__GetEmbedddedSkinUtilityModelPart()
KratosMultiphysics.Logger.PrintInfo(
'PartitionedEmbeddedFSIBaseSolver',
'Fluid solver construction finished')
KratosMultiphysics.Logger.PrintInfo(
'PartitionedEmbeddedFSIBaseSolver',
'Partitioned embedded FSI base solver construction finished')
def __init__(self, model, custom_settings):
self._validate_settings_in_baseclass = True # To be removed eventually
PythonSolver.__init__(self, model, custom_settings)
## Get domain size
self.domain_size = self.settings["domain_size"].GetInt()
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_solver_settings"], "OpenMP")
python_module_name = "KratosMultiphysics.FluidTransportApplication"
full_module_name = python_module_name + "." + self.settings[
"thermal_solver_settings"]["solver_type"].GetString()
solver_module = import_module(full_module_name)
self.thermal_solver = solver_module.CreateSolver(
self.model, self.settings["thermal_solver_settings"])
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, custom_settings):
super(CoupledFluidThermalSolver, self).__init__(model, custom_settings)
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type" : "ThermallyCoupled",
"domain_size" : -1,
"echo_level": 0,
"fluid_solver_settings": {
"solver_type": "navier_stokes_solver_vmsmonolithic",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
}
},
"thermal_solver_settings": {
"solver_type": "Transient",
"analysis_type": "linear",
"model_import_settings": {
"input_type": "use_input_model_part"
},
"material_import_settings": {
"materials_filename": "ThermalMaterials.json"
}
}
}
""")
## Overwrite the default settings with user-provided parameters
self.settings.ValidateAndAssignDefaults(default_settings)
## Get domain size
self.domain_size = self.settings["domain_size"].GetInt()
from KratosMultiphysics.FluidDynamicsApplication import python_solvers_wrapper_fluid
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_solver_settings"], "OpenMP")
from KratosMultiphysics.ConvectionDiffusionApplication import python_solvers_wrapper_convection_diffusion
self.thermal_solver = python_solvers_wrapper_convection_diffusion.CreateSolverByParameters(
self.model, self.settings["thermal_solver_settings"], "OpenMP")
def __init__(self, model, custom_settings):
super().__init__(model, custom_settings)
## Get domain size
self.domain_size = self.settings["domain_size"].GetInt()
## Set the fluid dynamics solver
from KratosMultiphysics.FluidDynamicsApplication import python_solvers_wrapper_fluid
self.fluid_solver = python_solvers_wrapper_fluid.CreateSolverByParameters(
self.model, self.settings["fluid_domain_solver_settings"]
["fluid_solver_settings"], "OpenMP")
# Set the fluid and solid heat solvers
from KratosMultiphysics.ConvectionDiffusionApplication import python_solvers_wrapper_convection_diffusion
self.fluid_thermal_solver = python_solvers_wrapper_convection_diffusion.CreateSolverByParameters(
self.model, self.settings["fluid_domain_solver_settings"]
["thermal_solver_settings"], "OpenMP")
self.solid_thermal_solver = python_solvers_wrapper_convection_diffusion.CreateSolverByParameters(
self.model, self.settings["solid_domain_solver_settings"]
["thermal_solver_settings"], "OpenMP")
def _CreateFluidSolver(self, solver_settings, parallelism):
return fluid_solvers_wrapper.CreateSolverByParameters(
self.model, solver_settings, parallelism)
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, 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.")
