def MoveMesh(self):
# move local and ghost nodes
self.mesh_model_part.GetCommunicator().SynchronizeVariable(
KratosMultiphysics.MESH_DISPLACEMENT)
KMM.MoveMesh(self.mesh_model_part.Nodes)
# If required, calculate the MESH_VELOCITY.
if self.settings["calculate_mesh_velocity"].GetBool():
KMM.CalculateMeshVelocities(self.mesh_model_part,
self.time_int_helper)
def __init__(self, model, custom_settings):
super(NavierStokesEmbeddedFMALEMonolithicSolver,self).__init__(model,custom_settings)
self.element_name = "EmbeddedNavierStokes"
self.condition_name = "NavierStokesWallCondition"
self.min_buffer_size = 3
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
# Retrieve the structural model part using json input
structure_model_part_name = self.settings["model_part_name"].GetString()
if self.model.HasModelPart(structure_model_part_name):
self.structure_model_part = self.model.GetModelPart(structure_model_part_name)
else:
raise Exception("Structural model part {0} not found in model".format(structure_model_part_name))
## Set the FM-ALE framework
self.fm_ale_step_frequency = self.settings["fm_ale_settings"]["fm_ale_step_frequency"].GetInt()
if (self.fm_ale_step_frequency != 0):
self.fm_ale_step = 1
self.virtual_model_part = KratosMultiphysics.ModelPart("VirtualModelPart")
self.mesh_moving_util = KratosMeshMoving.ExplicitMeshMovingUtilities(
self.virtual_model_part, self.structure_model_part, self.settings["fm_ale_settings"]["search_radius"].GetDouble())
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo("NavierStokesEmbeddedFMALEMonolithicSolver", "Construction of NavierStokesEmbeddedFMALEMonolithicSolver finished.")
def SolveSolutionStep(self):
# Calling Solve bcs this is what is currently implemented in the MeshSolverStrategies
# explicit bool conversion is only needed bcs "Solve" returns a double
is_converged = bool(self.get_mesh_motion_solving_strategy().Solve())
self.MoveMesh()
for variable in KratosMultiphysics.kratos_utilities.GenerateVariableListFromInput(self.settings["superimpose_mesh_disp_with"]):
KMM.SuperImposeMeshDisplacement(variable)
return is_converged
def test_ConstantTransformEuler(self):
points = self.GeneratePoints()
transform = MeshMoving.ParametricLinearTransform(
self.GetConstantEulerAngles(), self.GetConstantReferencePoint(),
self.GetConstantTranslationVector())
self.CheckDefaultTransformedPoints(
[transform.Apply(point, 0.0, 0.0, 0.0, 0.0) for point in points])
def _create_mesh_moving_util(self):
if have_mesh_moving:
mesh_movement = self.settings["fm_ale_settings"]["mesh_movement"].GetString()
if (mesh_movement == "implicit"):
mesh_moving_util = KratosMeshMoving.FixedMeshALEUtilities(
self.model,
self.settings["fm_ale_settings"]["fm_ale_solver_settings"])
elif (mesh_movement == "explicit"):
mesh_moving_util = KratosMeshMoving.ExplicitFixedMeshALEUtilities(
self.model,
self.settings["fm_ale_settings"]["fm_ale_solver_settings"])
else:
raise Exception("FM-ALE mesh_movement set to \'" + mesh_movement + "\'. Available options are \'implicit\' and \'explicit\'.")
return mesh_moving_util
else:
raise Exception("MeshMovingApplication is required to construct the FM-ALE utility (ExplicitFixedMeshALEUtilities)")
def SolveSolutionStep(self):
is_converged = True
for mesh_solver in self.mesh_motion_solvers:
is_converged &= mesh_solver.SolveSolutionStep()
for mesh_solver in self.mesh_motion_solvers:
KMM.CalculateMeshVelocities(
mesh_solver.GetComputingModelPart(),
self.time_int_helper)
for variable in KM.kratos_utilities.GenerateVariableListFromInput(self.settings["superimpose_mesh_velocity_with"]):
KMM.SuperImposeMeshVelocity(variable)
if self.fluid_solver.GetComputingModelPart().ProcessInfo[KM.TIME] >= self.start_fluid_solution_time:
self.__ApplyALEBoundaryCondition()
is_converged &= self.fluid_solver.SolveSolutionStep()
return is_converged
def _create_mesh_moving_util(self):
if have_mesh_moving:
mesh_moving_util = KratosMeshMoving.ExplicitMeshMovingUtilities(
self._get_fm_ale_virtual_model_part(),
self._get_fm_ale_structure_model_part(),
self.settings["fm_ale_settings"]["search_radius"].GetDouble())
return mesh_moving_util
else:
raise Exception("MeshMovingApplication is required to construct the FM-ALE utility (ExplicitMeshMovingUtilities)")
def _create_mesh_motion_solving_strategy(self):
linear_solver = self.get_linear_solver()
reform_dofs_each_step = self.settings["reform_dofs_each_step"].GetBool(
)
compute_reactions = self.settings["compute_reactions"].GetBool()
solving_strategy = KratosMeshMoving.LaplacianMeshMovingStrategy(
self.mesh_model_part, linear_solver, 0, reform_dofs_each_step,
compute_reactions, False, self.echo_level)
return solving_strategy
def _create_mesh_motion_solving_strategy(self):
linear_solver = self.get_linear_solver()
reform_dofs_each_step = self.settings["reform_dofs_each_step"].GetBool(
)
compute_reactions = self.settings["compute_reactions"].GetBool()
poisson_ratio = self.settings["poisson_ratio"].GetDouble()
solving_strategy = KratosMeshMoving.StructuralMeshMovingStrategy(
self.mesh_model_part, linear_solver, 0, reform_dofs_each_step,
compute_reactions, False, self.echo_level, poisson_ratio)
return solving_strategy
def test_EulerAngles(self):
euler_angles = [-math.pi / 2.0, -math.pi / 2.0, math.pi / 2.0]
reference_point = [-1.0, 0.0, 0.0]
translation_vector = [1.0, 2.0, 3.0]
transform = MeshMoving.LinearTransform(euler_angles, reference_point,
translation_vector)
self.CheckPoints(
[transform.Apply(point) for point in self.GeneratePoints()])
def SolveSolutionStep(self):
for mesh_solver in self.mesh_motion_solvers:
mesh_solver.SolveSolutionStep()
for mesh_solver in self.mesh_motion_solvers:
KMM.CalculateMeshVelocities(mesh_solver.GetComputingModelPart(),
self.time_int_helper)
self.__ApplyALEBoundaryCondition()
self.fluid_solver.SolveSolutionStep()
def test_AxisAngle(self):
axis = [0.0, 1.0, 0.0]
angle = -math.pi / 2.0
reference_point = [-1.0, 0.0, 0.0]
translation_vector = [1.0, 2.0, 3.0]
transform = MeshMoving.LinearTransform(axis, angle, reference_point,
translation_vector)
self.CheckPoints(
[transform.Apply(point) for point in self.GeneratePoints()])
def SolveSolutionStep(self):
for mesh_solver in self.mesh_motion_solvers:
mesh_solver.SolveSolutionStep()
for mesh_solver in self.mesh_motion_solvers:
KMM.CalculateMeshVelocities(mesh_solver.GetComputingModelPart(),
self.time_int_helper)
if self.fluid_solver.GetComputingModelPart().ProcessInfo[
KM.TIME] >= self.start_fluid_solution_time:
self.__ApplyALEBoundaryCondition()
self.fluid_solver.SolveSolutionStep()
def RunSolutionLoop(self):
"""custom to also compute the mesh-velocities"""
while self.KeepAdvancingSolutionLoop():
self.time = self._GetSolver().AdvanceInTime(self.time)
self.InitializeSolutionStep()
self._GetSolver().Predict()
self._GetSolver().SolveSolutionStep()
KMM.CalculateMeshVelocities(
self._GetSolver().GetComputingModelPart(),
self.mesh_vel_calc_helper)
self.FinalizeSolutionStep()
self.OutputSolutionStep()
def _create_mesh_motion_solving_strategy(self):
linear_solver = self.get_linear_solver()
time_order = self.settings["time_order"].GetInt()
reform_dofs_each_step = self.settings["reform_dofs_each_step"].GetBool(
)
compute_reactions = self.settings["compute_reactions"].GetBool()
calculate_mesh_velocities = self.settings[
"calculate_mesh_velocities"].GetBool()
echo_level = self.settings["echo_level"].GetInt()
solving_strategy = KratosMeshMoving.LaplacianMeshMovingStrategy(
self.mesh_model_part, linear_solver, time_order,
reform_dofs_each_step, compute_reactions,
calculate_mesh_velocities, echo_level)
return solving_strategy
def test_Quaternion(self):
quaternion = KratosMultiphysics.Quaternion()
quaternion.X = 0.0
quaternion.Y = -math.sqrt(2.0) / 2.0
quaternion.Z = 0.0
quaternion.W = math.sqrt(2.0) / 2.0
reference_point = [-1.0, 0.0, 0.0]
translation_vector = [1.0, 2.0, 3.0]
transform = MeshMoving.LinearTransform(quaternion, reference_point,
translation_vector)
self.CheckPoints(
[transform.Apply(point) for point in self.GeneratePoints()])
def test_euler_angles(self):
model_part = GenerateModelPart()
parameters = KratosMultiphysics.Parameters("""{
"rotation_definition" : "euler_angles",
"euler_angles" : [-1.57079632679, -1.57079632679, 1.57079632679],
"reference_point" : [-1, 0, 0],
"translation_vector" : [1, 2, 3]
}""")
MeshMovingApplication.ImposeMeshMotionProcess(
model_part,
parameters
).ExecuteInitializeSolutionStep()
self.CheckNodes(model_part)
def test_ParametricAxis(self):
points = self.GeneratePoints()
transform = MeshMoving.ParametricLinearTransform(
Parameters(""" ["t", "1.0-t", 0.0] """), self.GetConstantAngle(),
self.GetConstantReferencePoint(),
self.GetConstantTranslationVector())
self.CheckDefaultTransformedPoints(
[transform.Apply(point, 0.0, 0.0, 0.0, 0.0) for point in points])
self.assertVectorAlmostEqual(transform.Apply(points[0], 1.0, 0.0, 0.0,
0.0), [3.0, 2.0, 3.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[1], 1.0, 0.0, 0.0,
0.0), [1.0, 2.0, 1.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[2], 1.0, 0.0, 0.0,
0.0), [1.0, 4.0, 3.0],
prec=5)
def test_ParametricEulerAngles(self):
points = self.GeneratePoints()
transform = MeshMoving.ParametricLinearTransform(
Parameters(
f""" [{-math.pi/2.0}, {-math.pi/2.0}, "(1.0-t)*{math.pi/2.0}"] """
), self.GetConstantReferencePoint(),
self.GetConstantTranslationVector())
self.CheckDefaultTransformedPoints(
[transform.Apply(point, 0.0, 0.0, 0.0, 0.0) for point in points])
self.assertVectorAlmostEqual(transform.Apply(points[0], 1.0, 0.0, 0.0,
0.0), [0.0, -1.0, 3.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[1], 1.0, 0.0, 0.0,
0.0), [0.0, 1.0, 5.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[2], 1.0, 0.0, 0.0,
0.0), [-2.0, 1.0, 3.0],
prec=5)
def test_ParametricAngle(self):
points = self.GeneratePoints()
transform = MeshMoving.ParametricLinearTransform(
self.GetConstantAxis(),
Parameters(f""" "-(t+1.0) * {math.pi} / 2.0" """),
self.GetConstantReferencePoint(),
self.GetConstantTranslationVector())
self.CheckDefaultTransformedPoints(
[transform.Apply(point, 0.0, 0.0, 0.0, 0.0) for point in points])
self.assertVectorAlmostEqual(transform.Apply(points[0], 1.0, 0.0, 0.0,
0.0), [-3.0, 2.0, 3.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[1], 1.0, 0.0, 0.0,
0.0), [-1.0, 4.0, 3.0],
prec=5)
self.assertVectorAlmostEqual(transform.Apply(points[2], 1.0, 0.0, 0.0,
0.0), [-1.0, 2.0, 1.0],
prec=5)
def MoveMesh(self):
# move local and ghost nodes
self.mesh_model_part.GetCommunicator().SynchronizeVariable(KratosMultiphysics.MESH_DISPLACEMENT)
KMM.MoveMesh(self.mesh_model_part.Nodes)
def __init__(self, main_model_part, structure_model_part, custom_settings):
self.element_name = "EmbeddedNavierStokes"
self.condition_name = "NavierStokesWallCondition"
self.min_buffer_size = 3
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = True
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
self.structure_model_part = structure_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "embedded_solver_from_defaults",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"distance_reading_settings": {
"import_mode": "from_mdpa",
"distance_file_name": "no_distance_file"
},
"maximum_iterations": 7,
"dynamic_tau": 1.0,
"echo_level": 0,
"time_order": 2,
"compute_reactions": false,
"reform_dofs_at_each_step": false,
"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_NS_Solver"
},
"volume_model_part_name": "volume_model_part",
"skin_parts": [""],
"no_skin_parts":[""],
"time_stepping": {
"automatic_time_step": true,
"CFL_number": 1,
"minimum_delta_time": 1e-2,
"maximum_delta_time": 1.0
},
"move_mesh_flag": false,
"reorder": false,
"fm_ale_settings": {
"fm_ale_step_frequency": 1,
"search_radius" : 1.0
}
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solver
import linear_solver_factory
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
## Set the distance reading filename
# TODO: remove the manual "distance_file_name" set as soon as the problem type one has been tested.
if (self.settings["distance_reading_settings"]["import_mode"].GetString() == "from_GiD_file"):
self.settings["distance_reading_settings"]["distance_file_name"].SetString(self.settings["model_import_settings"]["input_filename"].GetString()+".post.res")
## Set the FM-ALE framework
self.fm_ale_step_frequency = self.settings["fm_ale_settings"]["fm_ale_step_frequency"].GetInt()
if (self.fm_ale_step_frequency != 0):
self.fm_ale_step = 1
self.virtual_model_part = KratosMultiphysics.ModelPart("VirtualModelPart")
self.mesh_moving_util = KratosMeshMoving.ExplicitMeshMovingUtilities(
self.virtual_model_part, self.structure_model_part, self.settings["fm_ale_settings"]["search_radius"].GetDouble())
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo("NavierStokesEmbeddedFMALEMonolithicSolver", "Construction of NavierStokesEmbeddedFMALEMonolithicSolver finished.")
def MoveMesh(self):
# move local and ghost nodes
KMM.MoveMesh(self.mesh_model_part.Nodes)
def ExecuteInitializeSolutionStep(self):
time = self.model_part.ProcessInfo[KratosMultiphysics.TIME]
if self.interval_utility.IsInInterval(time):
MeshMovingApplication.MoveModelPart(self.model_part, self.transform)
def __init__(self,
model: KratosMultiphysics.Model,
parameters: KratosMultiphysics.Parameters):
"""Impose a rotation followed by translation on a ModelPart."""
KratosMultiphysics.Process.__init__(self)
# 'rotation_angle' can either be a float or "End", but the validator can't handle both
# => convert 'rotation_angle' to the input type
default_parameters = self.GetDefaultParameters()
if parameters.Has("rotation_angle") and parameters["rotation_angle"].IsString():
default_parameters.RemoveValue("rotation_angle")
default_parameters.AddValue("rotation_angle", parameters["rotation_angle"])
parameters.ValidateAndAssignDefaults(default_parameters)
self.model_part = model[parameters["model_part_name"].GetString()]
# Parse interval
self.interval_utility = KratosMultiphysics.IntervalUtility(parameters)
# Determine whether a constant transform will suffice or a parametric one is needed
requires_parametric_transform = False
euler_angle_parameters = parameters["euler_angles"]
rotation_axis_parameters = parameters["rotation_axis"]
rotation_angle_parameters = parameters["rotation_angle"]
reference_point_parameters = parameters["reference_point"]
translation_vector_parameters = parameters["translation_vector"]
if rotation_angle_parameters.IsString():
requires_parametric_transform = True
else:
for i in range(3):
if euler_angle_parameters[i].IsString() or rotation_axis_parameters[i].IsString() or reference_point_parameters[i].IsString() or translation_vector_parameters[i].IsString():
requires_parametric_transform = True
break
rotation_definition = parameters["rotation_definition"].GetString()
if requires_parametric_transform:
if rotation_definition == "rotation_axis":
self.transform = MeshMovingApplication.ParametricLinearTransform(
rotation_axis_parameters,
rotation_angle_parameters,
reference_point_parameters,
translation_vector_parameters)
elif rotation_definition == "euler_angles":
self.transform = MeshMovingApplication.ParametricLinearTransform(
euler_angle_parameters,
reference_point_parameters,
translation_vector_parameters)
else:
raise ValueError("Invalid rotation definition '{}'".format(rotation_definition))
else:
reference_point = reference_point_parameters.GetVector()
translation_vector = translation_vector_parameters.GetVector()
if rotation_definition == "rotation_axis":
rotation_axis = rotation_axis_parameters.GetVector()
rotation_angle = rotation_angle_parameters.GetDouble()
self.transform = MeshMovingApplication.LinearTransform(
rotation_axis,
rotation_angle,
reference_point,
translation_vector)
elif rotation_definition == "euler_angles":
euler_angles = euler_angle_parameters.GetVector()
self.transform = MeshMovingApplication.LinearTransform(
euler_angles,
reference_point,
translation_vector)
else:
raise ValueError("Invalid rotation definition '{}'".format(rotation_definition))