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