def Initialize(self):
computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
# Set the time discretization utility to compute the BDF coefficients
time_order = self.settings["time_order"].GetInt()
if time_order == 2:
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(time_order)
else:
raise Exception("Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order))
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1) # DOFs (3,4)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(computing_model_part,
time_scheme,
self.linear_solver,
self.conv_criteria,
builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize() # Initialize the solver. Otherwise the constitutive law is not initializated.
# Set the distance modification process
self.__GetDistanceModificationProcess().ExecuteInitialize()
# For the primitive Ausas formulation, set the find nodal neighbours process
# Recall that the Ausas condition requires the nodal neighbours.
if (self.settings["formulation"]["element_type"].GetString() == "embedded_ausas_navier_stokes"):
number_of_avg_elems = 10
number_of_avg_nodes = 10
self.find_nodal_neighbours_process = KratosMultiphysics.FindNodalNeighboursProcess(self.GetComputingModelPart(),
number_of_avg_elems,
number_of_avg_nodes)
# If required, intialize the FM-ALE utility
if self.__fm_ale_is_active:
self.fm_ale_step = 1
# Fill the virtual model part geometry. Note that the mesh moving util is created in this first call
self._get_mesh_moving_util().Initialize(self.main_model_part)
KratosMultiphysics.Logger.PrintInfo("NavierStokesEmbeddedMonolithicSolver", "Solver initialization finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
if (self.settings["turbulence_model"].GetString() == "None"):
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE], KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
else:
raise Exception("Turbulence models are not added yet.")
if self.settings["consider_periodic_conditions"].GetBool() == True:
builder_and_solver = KratosCFD.ResidualBasedBlockBuilderAndSolverPeriodic(
self.linear_solver, KratosCFD.PATCH_INDEX)
else:
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.main_model_part, self.time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.OSS_SWITCH,
self.settings["oss_switch"].GetInt())
print("Monolithic solver initialization finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
MoveMeshFlag = False
# TODO: TURBULENCE MODELS ARE NOT ADDED YET
#~ # Turbulence model
#~ if self.use_spalart_allmaras:
#~ self.activate_spalart_allmaras()
# creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
self.time_scheme = KratosCFD.ResidualBasedSimpleSteadyScheme(
self.velocity_relaxation_factor, self.pressure_relaxation_factor,
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
# TODO: TURBULENCE MODELS ARE NOT ADDED YET
#~ if self.turbulence_model is None:
#~ if self.periodic == True:
#~ self.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent\
#~ (self.alpha, self.move_mesh_strategy, self.domain_size, PATCH_INDEX)
#~ else:
#~ self.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent\
#~ (self.alpha, self.move_mesh_strategy, self.domain_size)
#~ else:
#~ self.time_scheme = ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent\
#~ (self.alpha, self.move_mesh_strategy, self.domain_size, self.turbulence_model)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.main_model_part, self.time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
if self.settings["stabilization"].Has("dynamic_tau"):
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["stabilization"]["dynamic_tau"].GetDouble())
if self.settings["stabilization"].Has("oss_switch"):
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.OSS_SWITCH,
self.settings["stabilization"]["oss_switch"].GetInt())
print("Monolithic solver initialization finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
## Construct the linear solver
self.linear_solver = linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.computing_model_part, self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
self.neighbour_search = KratosMultiphysics.FindNodalNeighboursProcess(self.computing_model_part, 10, 10)
(self.neighbour_search).Execute()
self.accelerationLimitationUtility = KratosCFD.AccelerationLimitationUtilities( self.computing_model_part, 5.0 )
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
# Set the time discretization utility to compute the BDF coefficients
time_order = self.settings["time_order"].GetInt()
if time_order == 2:
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(time_order)
else:
raise Exception("Only \"time_order\" equal to 2 is supported. Provided \"time_order\": " + str(time_order))
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
self.level_set_convection_process = self._set_level_set_convection_process()
self.variational_distance_process = self._set_variational_distance_process()
time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1) # DOFs (3,4)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(self.computing_model_part,
time_scheme,
self.linear_solver,
self.conv_criteria,
builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize() # Initialize the solver. Otherwise the constitutive law is not initializated.
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(KratosMultiphysics.DYNAMIC_TAU, self.settings["formulation"]["dynamic_tau"].GetDouble())
KratosMultiphysics.Logger.PrintInfo("NavierStokesTwoFluidsSolver", "Solver initialization finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
# Creating the solution strategy
self.conv_criteria = KratosFluid.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
self.bdf_process = KratosMultiphysics.ComputeBDFCoefficientsProcess(
self.computing_model_part, self.settings["time_order"].GetInt())
if (self.settings["solver_type"].GetString() == "EmbeddedAusas"):
number_of_avg_elems = 10
number_of_avg_nodes = 10
self.find_nodal_neighbours_process = KratosMultiphysics.FindNodalNeighboursProcess(
self.computing_model_part, number_of_avg_elems,
number_of_avg_nodes)
time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(
self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] +
1) # DOFs (3,4)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.computing_model_part, time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize(
) # Initialize the solver. Otherwise the constitutive law is not initializated.
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
print("Monolithic embedded solver initialization finished.")
def _CreateConvergenceCriterion(self):
if self.settings["time_scheme"].GetString() == "steady":
convergence_criterion = KratosMultiphysics.ResidualCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble())
else:
convergence_criterion = KratosCFD.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
convergence_criterion.SetEchoLevel(
self.settings["echo_level"].GetInt())
return convergence_criterion
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._get_automatic_time_stepping_utility(
)
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
self.bdf_process = KratosMultiphysics.ComputeBDFCoefficientsProcess(
self.computing_model_part, self.settings["time_order"].GetInt())
time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(
self.main_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE], # Domain size (2,3)
self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] +
1) # DOFs (3,4)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.computing_model_part, time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
(self.solver).Initialize(
) # Initialize the solver. Otherwise the constitutive law is not initializated.
(self.solver).Check()
self.main_model_part.ProcessInfo.SetValue(
KratosMultiphysics.DYNAMIC_TAU,
self.settings["dynamic_tau"].GetDouble())
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesEmbeddedMonolithicSolver",
"Solver initialization finished.")
def __init__(self, model_part, settings):
self.model_part = model_part
#note that all settingsuration parameters MUST be passed.
self.domain_size = settings.domain_size
self.rel_vel_tol = settings.vel_tolerance
self.abs_vel_tol = settings.abs_vel_tolerance
self.rel_pres_tol = settings.press_tolerance
self.abs_pres_tol = settings.abs_press_tolerance
self.dynamic_tau = settings.dynamic_tau
self.max_iter = settings.max_iteration
self.echo_level = settings.echo_level
self.compute_reactions = settings.compute_reactions
self.reform_dofs_at_each_step = settings.reform_dofs_at_each_step
self.linear_solver = linear_solver_factory.ConstructSolver(
settings.linear_solver_settings)
time_order = 2
self.time_discretization = KratosMultiphysics.TimeDiscretization.BDF(
time_order)
self.conv_criteria = cfd.VelPrCriteria(self.rel_vel_tol,
self.abs_vel_tol,
self.rel_pres_tol,
self.abs_pres_tol)
(self.conv_criteria).SetEchoLevel(self.echo_level)
self.time_scheme = kratoscore.ResidualBasedIncrementalUpdateStaticScheme(
)
builder_and_solver = kratoscore.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
move_mesh_flag = False #user should NOT configure this
self.fluid_solver = kratoscore.ResidualBasedNewtonRaphsonStrategy(
self.model_part, self.time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver, self.max_iter,
self.compute_reactions, self.reform_dofs_at_each_step,
move_mesh_flag)
(self.fluid_solver).SetEchoLevel(self.echo_level)
self.fluid_solver.Check()
self.model_part.ProcessInfo.SetValue(kratoscore.DYNAMIC_TAU,
self.dynamic_tau)
print("Construction stokes solver finished")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility()
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
# Creating the time integration scheme
if (self.element_integrates_in_time):
# "Fake" scheme for those cases in where the element manages the time integration
# It is required to perform the nodal update once the current time step is solved
self.time_scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticSchemeSlip(
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE],
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]+1)
# In case the BDF2 scheme is used inside the element, the BDF process is required to update the BDF coefficients
if (self.settings["time_scheme"].GetString() == "bdf2"):
time_order = 2
self.bdf_process = KratosMultiphysics.ComputeBDFCoefficientsProcess(self.computing_model_part, time_order)
else:
err_msg = "Requested elemental time scheme " + self.settings["time_scheme"].GetString() + " is not available.\n"
err_msg += "Available options are: \"bdf2\""
raise Exception(err_msg)
else:
if (self.settings["turbulence_model"].GetString() == "None"):
# Bossak time integration scheme
if self.settings["time_scheme"].GetString() == "bossak":
if self.settings["consider_periodic_conditions"].GetBool() == True:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE],
KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosCFD.ResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
# BDF2 time integration scheme
elif self.settings["time_scheme"].GetString() == "bdf2":
self.time_scheme = KratosCFD.GearScheme()
# Time scheme for steady state fluid solver
elif self.settings["time_scheme"].GetString() == "steady":
self.time_scheme = KratosCFD.ResidualBasedSimpleSteadyScheme(
self.settings["velocity_relaxation"].GetDouble(),
self.settings["pressure_relaxation"].GetDouble(),
self.computing_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
else:
err_msg = "Requested time scheme " + self.settings["time_scheme"].GetString() + " is not available.\n"
err_msg += "Available options are: \"bossak\", \"bdf2\" and \"steady\""
raise Exception(err_msg)
else:
raise Exception("Turbulence models are not added yet.")
if self.settings["consider_periodic_conditions"].GetBool() == True:
builder_and_solver = KratosCFD.ResidualBasedBlockBuilderAndSolverPeriodic(self.linear_solver,
KratosCFD.PATCH_INDEX)
else:
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(self.computing_model_part,
self.time_scheme,
self.linear_solver,
self.conv_criteria,
builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
self.formulation.SetProcessInfo(self.computing_model_part)
(self.solver).Initialize()
KratosMultiphysics.Logger.PrintInfo("NavierStokesSolverMonolithic", "Solver initialization finished.")
def Initialize(self):
self.computing_model_part = self.GetComputingModelPart()
# If needed, create the estimate time step utility
if (self.settings["time_stepping"]["automatic_time_step"].GetBool()):
self.EstimateDeltaTimeUtility = self._GetAutomaticTimeSteppingUtility(
)
# Creating the solution strategy
self.conv_criteria = KratosCFD.VelPrCriteria(
self.settings["relative_velocity_tolerance"].GetDouble(),
self.settings["absolute_velocity_tolerance"].GetDouble(),
self.settings["relative_pressure_tolerance"].GetDouble(),
self.settings["absolute_pressure_tolerance"].GetDouble())
(self.conv_criteria).SetEchoLevel(self.settings["echo_level"].GetInt())
if (self.settings["turbulence_model"].GetString() == "None"):
if self.settings["time_scheme"].GetString() == "bossak":
if self.settings["consider_periodic_conditions"].GetBool(
) == True:
self.time_scheme = KratosPFEM2.ResidualBasedPredictorCorrectorVelocityBossakAleScheme(
self.settings["alpha"].GetDouble(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE],
KratosCFD.PATCH_INDEX)
else:
self.time_scheme = KratosPFEM2.ResidualBasedPredictorCorrectorVelocityBossakAleScheme(
self.settings["alpha"].GetDouble(),
self.settings["move_mesh_strategy"].GetInt(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
elif self.settings["time_scheme"].GetString() == "bdf2":
self.time_scheme = KratosCFD.GearScheme()
elif self.settings["time_scheme"].GetString() == "steady":
self.time_scheme = KratosCFD.ResidualBasedSimpleSteadyScheme(
self.settings["velocity_relaxation"].GetDouble(),
self.settings["pressure_relaxation"].GetDouble(),
self.computing_model_part.ProcessInfo[
KratosMultiphysics.DOMAIN_SIZE])
else:
raise Exception("Turbulence models are not added yet.")
if self.settings["consider_periodic_conditions"].GetBool() == True:
builder_and_solver = KratosCFD.ResidualBasedBlockBuilderAndSolverPeriodic(
self.linear_solver, KratosCFD.PATCH_INDEX)
else:
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosMultiphysics.ResidualBasedNewtonRaphsonStrategy(
self.computing_model_part, self.time_scheme, self.linear_solver,
self.conv_criteria, builder_and_solver,
self.settings["maximum_iterations"].GetInt(),
self.settings["compute_reactions"].GetBool(),
self.settings["reform_dofs_at_each_step"].GetBool(),
self.settings["move_mesh_flag"].GetBool())
(self.solver).SetEchoLevel(self.settings["echo_level"].GetInt())
self.formulation.SetProcessInfo(self.computing_model_part)
(self.solver).Initialize()
KratosMultiphysics.Logger.PrintInfo(
"PFEM2NavierStokesMonolithicSolver",
"Solver initialization finished.")