def testWallDistanceCalculationProcess(self):
settings = Kratos.Parameters(r'''
[
{
"kratos_module" : "KratosMultiphysics.RANSApplication",
"python_module" : "cpp_process_factory",
"process_name" : "WallDistanceCalculationProcess",
"Parameters" : {
"main_model_part_name" : "FluidModelPart",
"wall_model_part_name" : "FluidModelPart.Slip2D.Slip2D_walls",
"echo_level" : 0,
"max_distance" : 1e+30,
"max_levels" : 14,
"re_calculate_at_each_time_step" : false
}
}
]''')
test_variables = ["DISTANCE"]
test_model_part_name = "FluidModelPart"
test_file_name = "wall_distance_calculation_test_output"
CustomProcessTest._AddJsonCheckProcess(settings, test_variables,
test_model_part_name,
test_file_name)
# CustomProcessTest._AddJsonOutputProcess(settings, test_variables, test_model_part_name, test_file_name)
CalculateNormalsOnConditions(self.model_part)
self._RunProcessTest(settings)
def Initialize(self):
CalculateNormalsOnConditions(self.GetBaseModelPart())
solver_settings = self.GetParameters()
linear_solver = GetKratosObjectType("LinearSolverFactory")(
solver_settings["linear_solver_settings"])
builder_and_solver = CreateBlockBuilderAndSolver(
linear_solver, self.IsPeriodic(), self.GetCommunicator())
convergence_criteria = GetKratosObjectType("MixedGenericCriteria")([
(KratosRANS.VELOCITY_POTENTIAL,
solver_settings["relative_tolerance"].GetDouble(),
solver_settings["absolute_tolerance"].GetDouble())
])
self.velocity_strategy = GetKratosObjectType(
"ResidualBasedNewtonRaphsonStrategy")(
self.velocity_model_part,
GetKratosObjectType(
"ResidualBasedIncrementalUpdateStaticScheme")(),
convergence_criteria, builder_and_solver, 2, False, False,
False)
builder_and_solver.SetEchoLevel(
solver_settings["echo_level"].GetInt() - 3)
self.velocity_strategy.SetEchoLevel(
solver_settings["echo_level"].GetInt() - 2)
convergence_criteria.SetEchoLevel(
solver_settings["echo_level"].GetInt() - 1)
self.velocity_strategy.Initialize()
Kratos.Logger.PrintInfo(self.GetName(), "Initialized formulation")
def Initialize(self):
InitializeYPlusVariablesInConditions(self.GetBaseModelPart())
CalculateNormalsOnConditions(self.GetBaseModelPart())
settings = self.GetParameters()
if (self.IsPeriodic()):
InitializePeriodicConditions(
self.GetBaseModelPart(),
self.GetModelPart(),
[self.GetSolvingVariable()])
linear_solver_factory = GetKratosObjectPrototype("LinearSolverFactory")
linear_solver = linear_solver_factory(settings["linear_solver_settings"])
builder_and_solver = CreateBlockBuilderAndSolver(
linear_solver,
self.IsPeriodic(),
self.GetCommunicator())
convergence_criteria_type = GetKratosObjectPrototype("MixedGenericCriteria")
convergence_criteria = convergence_criteria_type([
(self.GetSolvingVariable(),
settings["relative_tolerance"].GetDouble(),
settings["absolute_tolerance"].GetDouble())])
if (self.is_steady_simulation):
scheme = self.scheme_type(settings["relaxation_factor"].GetDouble())
else:
scheme_type = GetKratosObjectPrototype("BossakRelaxationScalarScheme")
scheme = scheme_type(
self.GetModelPart().ProcessInfo[Kratos.BOSSAK_ALPHA],
settings["relaxation_factor"].GetDouble(),
self.GetSolvingVariable())
solver_type = GetKratosObjectPrototype("ResidualBasedNewtonRaphsonStrategy")
self.solver = solver_type(
self.GetModelPart(),
scheme,
convergence_criteria,
builder_and_solver,
settings["max_iterations"].GetInt(),
False,
False,
False)
self.solver.SetEchoLevel(self.echo_level)
convergence_criteria.SetEchoLevel(self.echo_level)
super().Initialize()
Kratos.Logger.PrintInfo(self.__class__.__name__, "Initialized formulation")
def Initialize(self):
model_part = self.GetBaseModelPart()
CalculateNormalsOnConditions(model_part)
process_info = model_part.ProcessInfo
bossak_alpha = process_info[Kratos.BOSSAK_ALPHA]
settings = self.GetParameters()
if (self.IsPeriodic()):
if (self.GetDomainSize() == 2):
periodic_variables_list = [
Kratos.VELOCITY_X, Kratos.VELOCITY_Y, Kratos.PRESSURE
]
else:
periodic_variables_list = [
Kratos.VELOCITY_X, Kratos.VELOCITY_Y, Kratos.VELOCITY_Z,
Kratos.PRESSURE
]
InitializePeriodicConditions(model_part,
self.monolithic_model_part,
periodic_variables_list)
conv_criteria_type = GetKratosObjectPrototype("MixedGenericCriteria")
conv_criteria = conv_criteria_type([
(Kratos.VELOCITY,
settings["relative_velocity_tolerance"].GetDouble(),
settings["absolute_velocity_tolerance"].GetDouble()),
(Kratos.PRESSURE,
settings["relative_pressure_tolerance"].GetDouble(),
settings["absolute_pressure_tolerance"].GetDouble())
])
if self.is_steady_simulation:
scheme_type = GetKratosObjectPrototype(
"ResidualBasedSimpleSteadyScheme")
scheme = scheme_type(settings["velocity_relaxation"].GetDouble(),
settings["pressure_relaxation"].GetDouble(),
self.GetDomainSize())
else:
scheme_type = GetKratosObjectPrototype(
"ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent")
scheme = scheme_type(bossak_alpha,
settings["move_mesh_strategy"].GetInt(),
self.GetDomainSize())
linear_solver_factory = GetKratosObjectPrototype("LinearSolverFactory")
linear_solver = linear_solver_factory(
settings["linear_solver_settings"])
builder_and_solver = CreateBlockBuilderAndSolver(
linear_solver, self.IsPeriodic(), self.GetCommunicator())
solver_type = GetKratosObjectPrototype(
"ResidualBasedNewtonRaphsonStrategy")
self.solver = solver_type(
self.monolithic_model_part, scheme, conv_criteria,
builder_and_solver, settings["maximum_iterations"].GetInt(),
settings["compute_reactions"].GetBool(),
settings["reform_dofs_at_each_step"].GetBool(),
settings["move_mesh_flag"].GetBool())
self.solver.SetEchoLevel(self.echo_level)
conv_criteria.SetEchoLevel(self.echo_level)
super().Initialize()
Kratos.Logger.PrintInfo(self.__class__.__name__,
"Solver initialization finished.")
def Initialize(self):
model_part = self.GetBaseModelPart()
CalculateNormalsOnConditions(model_part)
process_info = model_part.ProcessInfo
wall_model_part_name = process_info[KratosRANS.WALL_MODEL_PART_NAME]
wall_function_update_process = KratosRANS.RansWallFunctionUpdateProcess(
model_part.GetModel(),
wall_model_part_name,
self.echo_level)
self.AddProcess(wall_function_update_process)
if (self.IsPeriodic()):
InitializePeriodicConditions(
model_part,
self.fractional_step_model_part,
None,
"FSPeriodicCondition{0:d}D".format(self.GetDomainSize()))
settings = self.GetParameters()
self.solver_settings = self._CreateSolverSettings(
self.fractional_step_model_part,
self.GetDomainSize(),
settings["time_order"].GetInt(),
True,
self.GetMoveMeshFlag(),
settings["reform_dofs_at_each_step"].GetBool())
self.solver_settings.SetEchoLevel(self.echo_level)
## Construct the linear solvers
linear_solver_factory = GetKratosObjectPrototype("LinearSolverFactory")
pressure_linear_solver = linear_solver_factory(settings["pressure_linear_solver_settings"])
velocity_linear_solver = linear_solver_factory(settings["velocity_linear_solver_settings"])
strategy_label_type = GetKratosObjectPrototype("StrategyLabel")
self.solver_settings.SetStrategy(
strategy_label_type.Velocity,
velocity_linear_solver,
settings["velocity_tolerance"].GetDouble(),
settings["maximum_velocity_iterations"].GetInt())
self.solver_settings.SetStrategy(
strategy_label_type.Pressure,
pressure_linear_solver,
settings["pressure_tolerance"].GetDouble(),
settings["maximum_pressure_iterations"].GetInt())
solver_type = GetKratosObjectPrototype("FractionalStepStrategy")
if self.IsPeriodic():
self.solver = solver_type(
self.fractional_step_model_part,
self.solver_settings,
settings["predictor_corrector"].GetBool(),
False,
KratosCFD.PATCH_INDEX)
else:
self.solver = solver_type(
self.fractional_step_model_part,
self.solver_settings,
settings["predictor_corrector"].GetBool(),
False)
process_info.SetValue(Kratos.DYNAMIC_TAU, settings["dynamic_tau"].GetDouble())
process_info.SetValue(Kratos.OSS_SWITCH, settings["oss_switch"].GetInt())
super().Initialize()
Kratos.Logger.PrintInfo(self.__class__.__name__, "Solver initialization finished.")