def __init__(self, model, custom_settings):
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(
navier_stokes_solver_fractionalstep.
NavierStokesSolverFractionalStep,
self).__init__(model, custom_settings)
self.element_name = "FractionalStep"
self.condition_name = "WallCondition"
self.min_buffer_size = 3
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
## Construct the linear solvers
import trilinos_linear_solver_factory
self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverFractionalStep",
"Construction of TrilinosNavierStokesSolverFractionalStep solver finished."
)
def CreateSolver(model_part, config):
fluid_solver = IncompressibleFluidSolver(model_part, config.domain_size)
# default settings
fluid_solver.vel_toll = config.vel_toll
if(hasattr(config, "vel_toll")):
fluid_solver.vel_toll = config.vel_toll
if(hasattr(config, "press_toll")):
fluid_solver.press_toll = config.press_toll
if(hasattr(config, "max_vel_its")):
fluid_solver.max_vel_its = config.max_vel_its
if(hasattr(config, "max_press_its")):
fluid_solver.max_press_its = config.max_press_its
if(hasattr(config, "time_order")):
fluid_solver.time_order = config.time_order
if(hasattr(config, "compute_reactions")):
fluid_solver.compute_reactions = config.compute_reactions
if(hasattr(config, "ReformDofAtEachIteration")):
fluid_solver.ReformDofAtEachIteration = config.ReformDofAtEachIteration
if(hasattr(config, "predictor_corrector")):
fluid_solver.predictor_corrector = config.predictor_corrector
if(hasattr(config, "echo_level")):
fluid_solver.echo_level = config.echo_level
if(hasattr(config, "dynamic_tau")):
fluid_solver.dynamic_tau = config.dynamic_tau
# linear solver settings
import trilinos_linear_solver_factory
if(hasattr(config, "pressure_linear_solver_config")):
fluid_solver.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
config.pressure_linear_solver_config)
if(hasattr(config, "velocity_linear_solver_config")):
fluid_solver.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
config.velocity_linear_solver_config)
if(hasattr(config, "divergence_cleareance_step")):
fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step
# RANS or DES settings
if hasattr(config, "TurbulenceModel"):
if config.TurbulenceModel == "Spalart-Allmaras":
fluid_solver.use_spalart_allmaras = True
elif config.TurbulenceModel == "Smagorinsky-Lilly":
if hasattr(config, "SmagorinskyConstant"):
fluid_solver.activate_smagorinsky(config.SmagorinskyConstant)
else:
msg = """Fluid solver error: Smagorinsky model requested, but
the value for the Smagorinsky constant is
undefined."""
raise Exception(msg)
return fluid_solver
def testTrilinosRedistance(self):
# Set the model part
current_model = KratosMultiphysics.Model()
self.model_part = current_model.CreateModelPart(
"RedistanceCalculationPart")
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.FLAG_VARIABLE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters(self.parameters)
TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility(
self.model_part, import_settings)
TrilinosModelPartImporter.ImportModelPart()
TrilinosModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Initialize the DISTANCE values
for node in self.model_part.Nodes:
node.SetSolutionStepValue(
KratosMultiphysics.DISTANCE, 0,
self._ExpectedDistance(node.X, node.Y, node.Z))
# Fake time advance
self.model_part.CloneTimeStep(1.0)
# Set the utility and compute the variational distance values
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters(
"""{"solver_type" : "AmesosSolver" }"""))
epetra_comm = TrilinosApplication.CreateCommunicator()
max_iterations = 2
TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D(
epetra_comm, self.model_part, trilinos_linear_solver,
max_iterations).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
min_distance = self.model_part.GetCommunicator().MinAll(min_distance)
max_distance = self.model_part.GetCommunicator().MaxAll(max_distance)
self.assertAlmostEqual(max_distance,
0.44556526310761013) # Serial max_distance
self.assertAlmostEqual(min_distance,
-0.504972246827639) # Serial min_distance
def __init__(self, model, custom_settings):
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(
navier_stokes_embedded_solver.NavierStokesEmbeddedMonolithicSolver,
self).__init__(model, custom_settings)
self.element_name = "EmbeddedNavierStokes"
self.condition_name = "NavierStokesWallCondition"
self.min_buffer_size = 3
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
# TODO: Remove this once we finish the new implementations
if (self.settings["solver_type"].GetString() == "EmbeddedDevelopment"):
self.element_name = "EmbeddedSymbolicNavierStokes"
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPIEmbeddedMonolithicSolver",
"Construction of NavierStokesMPIEmbeddedMonolithicSolver finished."
)
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the computing_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "trilinos_structural_mechanics_implicit_dynamic_solver",
"echo_level": 0,
"buffer_size": 2,
"solution_type": "Dynamic",
"time_integration_method": "Implicit",
"scheme_type": "Newmark",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name",
"input_file_label": 0
},
"rotation_dofs": false,
"pressure_dofs": false,
"stabilization_factor": 1.0,
"reform_dofs_at_each_step": false,
"line_search": false,
"implex": false,
"compute_reactions": false,
"compute_contact_forces": false,
"block_builder": true,
"clear_storage": false,
"component_wise": false,
"move_mesh_flag": true,
"convergence_criterion": "Residual_criteria",
"displacement_relative_tolerance": 1.0e-4,
"displacement_absolute_tolerance": 1.0e-9,
"residual_relative_tolerance": 1.0e-4,
"residual_absolute_tolerance": 1.0e-9,
"max_iteration": 10,
"linear_solver_settings":{
"solver_type" : "Klu",
"scaling": false
},
"bodies_list": [],
"problem_domain_sub_model_part_list": ["solid_model_part"],
"processes_sub_model_part_list": [""]
}
""")
##overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
#construct the linear solver
import trilinos_linear_solver_factory
self.linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
print("Construction of Implicit Mechanical MPI Solver finished")
def __init__(self, model, custom_settings):
super(AdjointVMSMonolithicSolver, self).__init__(model, custom_settings)
self.element_name = "VMSAdjointElement"
if self.settings["domain_size"].GetInt() == 2:
self.condition_name = "LineCondition"
elif self.settings["domain_size"].GetInt() == 3:
self.condition_name = "SurfaceCondition"
self.min_buffer_size = 2
# construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointVMSMonolithicMPISolver finished.")
def CreateSolver(model_part, config):
fluid_solver = MonolithicSolver(model_part, config.domain_size)
if(hasattr(config, "alpha")):
fluid_solver.alpha = config.alpha
# definition of the convergence criteria
if(hasattr(config, "velocity_relative_tolerance")):
fluid_solver.rel_vel_tol = config.velocity_relative_tolerance
if(hasattr(config, "velocity_absolute_tolerance")):
fluid_solver.abs_vel_tol = config.velocity_absolute_tolerance
if(hasattr(config, "pressure_relative_tolerance")):
fluid_solver.rel_pres_tol = config.pressure_relative_tolerance
if(hasattr(config, "pressure_absolute_tolerance")):
fluid_solver.abs_pres_tol = config.pressure_absolute_tolerance
if(hasattr(config, "dynamic_tau")):
fluid_solver.dynamic_tau = config.dynamic_tau
if(hasattr(config, "oss_switch")):
fluid_solver.oss_switch = config.oss_switch
if(hasattr(config, "max_iteration")):
fluid_solver.max_iter = config.max_iteration
if(hasattr(config, "echo_level")):
fluid_solver.echo_level = config.echo_level
if(hasattr(config, "compute_reactions")):
fluid_solver.compute_reactions = config.compute_reactions
if(hasattr(config, "ReformDofSetAtEachStep")):
fluid_solver.ReformDofSetAtEachStep = config.ReformDofSetAtEachStep
if(hasattr(config, "divergence_cleareance_step")):
fluid_solver.divergence_clearance_steps = config.divergence_cleareance_step
import trilinos_linear_solver_factory
if(hasattr(config, "linear_solver_config")):
fluid_solver.linear_solver = trilinos_linear_solver_factory.ConstructSolver(
config.linear_solver_config)
if hasattr(config, "TurbulenceModel"):
if config.TurbulenceModel == "Spalart-Allmaras":
fluid_solver.use_spalart_allmaras = True
elif config.TurbulenceModel == "Smagorinsky-Lilly":
if hasattr(config, "SmagorinskyConstant"):
fluid_solver.activate_smagorinsky(config.SmagorinskyConstant)
else:
msg = """Fluid solver error: Smagorinsky model requested, but
the value for the Smagorinsky constant is
undefined."""
raise Exception(msg)
return fluid_solver
def __init__(self, model, custom_settings):
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(navier_stokes_embedded_solver.NavierStokesEmbeddedMonolithicSolver, self).__init__(model,custom_settings)
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
self.min_buffer_size = 3
self.embedded_formulation = navier_stokes_embedded_solver.EmbeddedFormulation(self.settings["formulation"])
self.element_name = self.embedded_formulation.element_name
self.condition_name = self.embedded_formulation.condition_name
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo("NavierStokesMPIEmbeddedMonolithicSolver","Construction of NavierStokesMPIEmbeddedMonolithicSolver finished.")
def __init__(self, model, custom_settings):
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic, self).__init__(model,custom_settings)
self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.min_buffer_size = 2
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.Print("Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings):
# Note: deliberately calling the constructor of the base python solver (the parent of my parent)
super(navier_stokes_solver_vmsmonolithic.NavierStokesSolverMonolithic,
self).__init__(model, custom_settings)
self.formulation = navier_stokes_solver_vmsmonolithic.StabilizedFormulation(
self.settings["formulation"])
self.element_name = self.formulation.element_name
self.condition_name = self.formulation.condition_name
self.min_buffer_size = 2
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.Print(
"Construction of TrilinosNavierStokesSolverMonolithic finished.")
def __init__(self, model, custom_settings):
super(AdjointVMSMonolithicSolver, self).__init__(model, custom_settings)
# There is only a single rank in OpenMP, we always print
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
self.element_name = "VMSAdjointElement"
if self.settings["domain_size"].GetInt() == 2:
self.condition_name = "LineCondition"
elif self.settings["domain_size"].GetInt() == 3:
self.condition_name = "SurfaceCondition"
self.min_buffer_size = 2
# construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo(self.__class__.__name__, "Construction of AdjointVMSMonolithicMPISolver finished.")
def __init__(self, model, custom_settings):
# the constructor of the "grand-parent" (jumping constructor of parent) is called to avoid conflicts in attribute settings
super(navier_stokes_two_fluids_solver.NavierStokesTwoFluidsSolver,
self).__init__(model, custom_settings)
self.element_name = "TwoFluidNavierStokes"
self.condition_name = "NavierStokesWallCondition"
self.min_buffer_size = 3
if (self.settings["solver_type"].GetString() == "TwoFluids"):
self.element_name = "TwoFluidNavierStokes"
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPITwoFluidsSolver",
"Construction of NavierStokesMPITwoFluidsSolver finished.")
def __init__(self, main_model_part, custom_settings):
self.main_model_part = main_model_part
# default settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "trilinos_adjoint_vmsmonolithic_solver",
"scheme_settings" : {
"scheme_type": "bossak"
},
"response_function_settings" : {
"response_type" : "drag"
},
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"linear_solver_settings" : {
"solver_type" : "MultiLevelSolver"
},
"volume_model_part_name" : "volume_model_part",
"skin_parts": [""],
"dynamic_tau": 0.0,
"oss_switch": 0,
"echo_level": 0
}""")
# overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
# construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
if KratosMPI.mpi.rank == 0:
print("Construction of AdjointVMSMonolithicMPISolver finished.")
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the computing_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "dam_MPI_mechanical_solver",
"model_import_settings":{
"input_type": "mdpa",
"input_filename": "unknown_name",
"input_file_label": 0
},
"buffer_size": 2,
"echo_level": 0,
"processes_sub_model_part_list": [""],
"mechanical_solver_settings":{
"echo_level": 0,
"reform_dofs_at_each_step": false,
"clear_storage": false,
"compute_reactions": false,
"move_mesh_flag": true,
"solution_type": "Quasi-Static",
"scheme_type": "Newmark",
"rayleigh_m": 0.0,
"rayleigh_k": 0.0,
"strategy_type": "Newton-Raphson",
"convergence_criterion": "Displacement_criterion",
"displacement_relative_tolerance": 1.0e-4,
"displacement_absolute_tolerance": 1.0e-9,
"residual_relative_tolerance": 1.0e-4,
"residual_absolute_tolerance": 1.0e-9,
"max_iteration": 15,
"desired_iterations": 4,
"max_radius_factor": 20.0,
"min_radius_factor": 0.5,
"block_builder": true,
"nonlocal_damage": false,
"characteristic_length": 0.05,
"search_neighbours_step": false,
"linear_solver_settings":{
"solver_type": "AMGCL",
"tolerance": 1.0e-6,
"max_iteration": 100,
"scaling": false,
"verbosity": 0,
"preconditioner_type": "ILU0Preconditioner",
"smoother_type": "ilu0",
"krylov_type": "gmres",
"coarsening_type": "aggregation"
},
"problem_domain_sub_model_part_list": [""],
"body_domain_sub_model_part_list": [],
"mechanical_loads_sub_model_part_list": [],
"loads_sub_model_part_list": [],
"loads_variable_list": []
}
}
""")
# Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
# Construct the linear solver
import trilinos_linear_solver_factory
self.linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["mechanical_solver_settings"]
["linear_solver_settings"])
print("Construction of Dam_MPI_MechanicalSolver finished")
def _ConstructLinearSolver(self):
import trilinos_linear_solver_factory
linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
return linear_solver
def _auxiliary_test_function(self,
settings,
matrix_name="A.mm",
absolute_norm=False):
comm = KratosMultiphysics.TrilinosApplication.CreateCommunicator()
space = KratosMultiphysics.TrilinosApplication.TrilinosSparseSpace()
#read the matrices
pA = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name), comm)
n = space.Size1(pA.GetReference())
pAoriginal = space.ReadMatrixMarketMatrix(GetFilePath(matrix_name),
comm)
pb = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(pb, n)
space.SetToZeroVector(pb.GetReference())
space.SetValue(pb.GetReference(), 0, 1.0) #pb[1] = 1.0
px = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(px, n)
pboriginal = space.CreateEmptyVectorPointer(comm) #create a copy of b
space.ResizeVector(pboriginal, n)
space.SetToZeroVector(pboriginal.GetReference())
space.UnaliasedAdd(pboriginal.GetReference(), 1.0, pb.GetReference())
space.SetToZeroVector(px.GetReference())
#space.SetToZeroVector(boriginal)
#space.UnaliasedAdd(boriginal, 1.0, b) #boriginal=1*bs
#construct the solver
import trilinos_linear_solver_factory
linear_solver = trilinos_linear_solver_factory.ConstructSolver(
settings)
#solve
linear_solver.Solve(pA.GetReference(), px.GetReference(),
pb.GetReference())
#test the results
ptmp = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(ptmp, n)
space.SetToZeroVector(ptmp.GetReference())
space.Mult(pAoriginal.GetReference(), px.GetReference(),
ptmp.GetReference())
pcheck = space.CreateEmptyVectorPointer(comm)
space.ResizeVector(pcheck, n)
space.SetToZeroVector(pcheck.GetReference())
space.UnaliasedAdd(pcheck.GetReference(), 1.0,
pboriginal.GetReference())
space.UnaliasedAdd(pcheck.GetReference(), -1.0, ptmp.GetReference())
achieved_norm = space.TwoNorm(pcheck.GetReference())
tolerance = 1e-9
if (settings.Has("tolerance")):
tolerance = settings["tolerance"].GetDouble()
nproc = KratosMultiphysics.mpi.mpi.size
target_norm = tolerance * space.TwoNorm(
pboriginal.GetReference()
) * nproc #multiplying by nproc the target tolerance to give some slack. Not really nice :-(
if (achieved_norm > target_norm):
print("target_norm :", target_norm)
print("achieved_norm :", achieved_norm)
self.assertTrue(achieved_norm <= target_norm)
#destroy the preconditioner - this is needed since the solver should be destroyed before the destructor of the system matrix is called
del linear_solver
def __init__(self, main_model_part, custom_settings):
self.element_name = "FractionalStep"
self.condition_name = "WallCondition"
self.min_buffer_size = 3
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
## Default settings string in Json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "FractionalStep",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"predictor_corrector": false,
"maximum_velocity_iterations": 3,
"maximum_pressure_iterations": 3,
"velocity_tolerance": 1e-3,
"pressure_tolerance": 1e-2,
"dynamic_tau": 0.01,
"oss_switch": 0,
"echo_level": 0,
"consider_periodic_conditions": false,
"time_order": 2,
"compute_reactions": false,
"reform_dofs_at_each_step": false,
"pressure_linear_solver_settings": {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-6,
"symmetric" : true,
"scaling" : true,
"reform_preconditioner_at_each_step" : true,
"verbosity" : 0
},
"velocity_linear_solver_settings": {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-6,
"symmetric" : false,
"scaling" : true,
"reform_preconditioner_at_each_step" : true,
"verbosity" : 0
},
"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-4,
"maximum_delta_time" : 0.01
},
"move_mesh_flag": false,
"use_slip_conditions": true
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solvers
import trilinos_linear_solver_factory
self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
self.compute_reactions = self.settings["compute_reactions"].GetBool()
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.PrintInfo(
"TrilinosNavierStokesSolverFractionalStep",
"Construction of TrilinosNavierStokesSolverFractionalStep solver finished."
)
def _create_linear_solver(self):
import trilinos_linear_solver_factory
linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["mesh_motion_linear_solver_settings"])
return linear_solver
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
## Default settings string in Json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "trilinos_navier_stokes_solver_fractionalstep",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"predictor_corrector": false,
"maximum_velocity_iterations": 3,
"maximum_pressure_iterations": 3,
"velocity_tolerance": 1e-3,
"pressure_tolerance": 1e-2,
"dynamic_tau": 0.01,
"oss_switch": 0,
"echo_level": 0,
"consider_periodic_conditions": false,
"time_order": 2,
"compute_reactions": false,
"reform_dofs_at_each_step": false,
"pressure_linear_solver_settings": {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-6,
"symmetric" : true,
"scaling" : true,
"reform_preconditioner_at_each_step" : true,
"verbosity" : 0
},
"velocity_linear_solver_settings": {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-6,
"symmetric" : false,
"scaling" : true,
"reform_preconditioner_at_each_step" : true,
"verbosity" : 0
},
"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-4,
"maximum_delta_time" : 0.01
},
"move_mesh_flag": false,
"use_slip_conditions": true
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
self.compute_reactions = self.settings["compute_reactions"].GetBool()
## Construct the linear solvers
import trilinos_linear_solver_factory
self.settings["pressure_linear_solver_settings"].PrettyPrintJsonString(
)
self.pressure_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["pressure_linear_solver_settings"])
self.velocity_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["velocity_linear_solver_settings"])
## Set the element replace settings
if main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2:
default_element = "FractionalStep2D3N"
default_condition = "WallCondition2D2N"
elif main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3:
default_element = "FractionalStep3D4N"
default_condition = "WallCondition3D3N"
else:
Msg = 'Trilinos_NavierStokesSolver_FractionalStep Error:\n'
Msg += 'Unsupported number of dimensions: {0}\n'.format(
main_model_part.ProcessInfo[DOMAIN_SIZE])
raise Exception(Msg)
self.settings.AddEmptyValue("element_replace_settings")
self.settings["element_replace_settings"].AddEmptyValue("element_name")
self.settings["element_replace_settings"]["element_name"].SetString(
default_element)
self.settings["element_replace_settings"].AddEmptyValue(
"condition_name")
self.settings["element_replace_settings"]["condition_name"].SetString(
default_condition)
print(
"Construction of Trilinos_NavierStokesSolver_FractionalStep finished"
)
def __init__(self, main_model_part, custom_settings):
self.element_name = "VMS"
self.condition_name = "MonolithicWallCondition"
self.min_buffer_size = 2
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
## Default settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "trilinos_navier_stokes_solver_vmsmonolithic",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"maximum_iterations": 10,
"dynamic_tau": 0.01,
"oss_switch": 0,
"echo_level": 0,
"consider_periodic_conditions": false,
"time_order": 2,
"compute_reactions": false,
"reform_dofs_at_each_step": false,
"relative_velocity_tolerance": 1e-5,
"absolute_velocity_tolerance": 1e-7,
"relative_pressure_tolerance": 1e-5,
"absolute_pressure_tolerance": 1e-7,
"linear_solver_settings" : {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-8,
"max_levels" : 3,
"symmetric" : false,
"reform_preconditioner_at_each_step" : true,
"scaling" : true
},
"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-4,
"maximum_delta_time" : 0.01
},
"time_scheme": "bossak",
"alpha":-0.3,
"move_mesh_strategy": 0,
"periodic": "periodic",
"regularization_coef": 1000,
"move_mesh_flag": false,
"turbulence_model": "None"
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
if self._IsPrintingRank():
#TODO: CHANGE THIS ONCE THE MPI LOGGER IS IMPLEMENTED
KratosMultiphysics.Logger.Print(
"Construction of TrilinosNavierStokesSolverMonolithic finished."
)
def __init__(self, main_model_part, custom_settings):
self.element_name = "EmbeddedAusasNavierStokes"
self.condition_name = "EmbeddedAusasNavierStokesWallCondition"
self.min_buffer_size = 3
self._is_printing_rank = (KratosMPI.mpi.rank == 0)
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "EmbeddedAusas",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"distance_reading_settings" : {
"import_mode" : "from_GID_file",
"distance_file_name" : "distance_file"
},
"maximum_iterations": 7,
"dynamic_tau": 1.0,
"echo_level": 0,
"consider_periodic_conditions": false,
"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" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-6,
"max_levels" : 3,
"symmetric" : false,
"reform_preconditioner_at_each_step" : true,
"scaling" : true
},
"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-4,
"maximum_delta_time" : 0.01
},
"periodic": "periodic",
"move_mesh_flag": false
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_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")
if self._IsPrintingRank():
KratosMultiphysics.Logger.PrintInfo(
"NavierStokesMPIEmbeddedAusasMonolithicSolver",
"Construction of NavierStokesEmbeddedAusasSolver finished.")
def __init__(self, main_model_part, custom_settings):
#TODO: shall obtain the compute_model_part from the MODEL once the object is implemented
self.main_model_part = main_model_part
## Default settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type": "trilinos_navier_stokes_solver_vmsmonolithic",
"model_import_settings": {
"input_type": "mdpa",
"input_filename": "unknown_name"
},
"maximum_iterations": 10,
"dynamic_tau": 0.01,
"oss_switch": 0,
"echo_level": 0,
"consider_periodic_conditions": false,
"time_order": 2,
"compute_reactions": false,
"divergence_clearance_steps": 0,
"reform_dofs_at_each_step": false,
"relative_velocity_tolerance": 1e-5,
"absolute_velocity_tolerance": 1e-7,
"relative_pressure_tolerance": 1e-5,
"absolute_pressure_tolerance": 1e-7,
"linear_solver_settings" : {
"solver_type" : "MultiLevelSolver",
"max_iteration" : 200,
"tolerance" : 1e-8,
"max_levels" : 3,
"symmetric" : false,
"reform_preconditioner_at_each_step" : true,
"scaling" : true
},
"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-4,
"maximum_delta_time" : 0.01
},
"alpha":-0.3,
"move_mesh_strategy": 0,
"periodic": "periodic",
"regularization_coef": 1000,
"move_mesh_flag": false,
"turbulence_model": "None"
}""")
## Overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Construct the linear solver
import trilinos_linear_solver_factory
self.trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(self.settings["linear_solver_settings"])
## Set the element replace settings
self.settings.AddEmptyValue("element_replace_settings")
if(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 3):
self.settings["element_replace_settings"] = KratosMultiphysics.Parameters("""
{
"element_name":"VMS3D4N",
"condition_name": "MonolithicWallCondition3D"
}
""")
elif(self.main_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] == 2):
self.settings["element_replace_settings"] = KratosMultiphysics.Parameters("""
{
"element_name":"VMS2D3N",
"condition_name": "MonolithicWallCondition2D"
}
""")
else:
raise Exception("Domain size is neither 2 nor 3!!")
print("Construction of NavierStokesMPISolver_VMSMonolithic finished.")
def _create_linear_solver(self):
import trilinos_linear_solver_factory # TODO: Is new_trilinos_linear_solver_factory or trilinos_linear_solver_factory?
linear_solver = trilinos_linear_solver_factory.ConstructSolver(
self.settings["linear_solver_settings"])
return linear_solver
def test_trilinos_levelset_convection(self):
self.model_part = KratosMultiphysics.ModelPart("Main")
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.DISTANCE)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.VELOCITY)
self.model_part.AddNodalSolutionStepVariable(
KratosMultiphysics.PARTITION_INDEX)
# Import the model part, perform the partitioning and create communicators
import_settings = KratosMultiphysics.Parameters("""{
"echo_level" : 0,
"model_import_settings" : {
"input_type" : "mdpa",
"input_filename" : "levelset_convection_process_mesh"
}
}""")
import trilinos_import_model_part_utility
TrilinosModelPartImporter = trilinos_import_model_part_utility.TrilinosImportModelPartUtility(
self.model_part, import_settings)
TrilinosModelPartImporter.ImportModelPart()
TrilinosModelPartImporter.CreateCommunicators()
# Recall to set the buffer size
self.model_part.SetBufferSize(2)
# Set the initial distance field and the convection velocity
for node in self.model_part.Nodes:
node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0,
BaseDistance(node.X, node.Y, node.Z))
node.SetSolutionStepValue(
KratosMultiphysics.VELOCITY, 0,
ConvectionVelocity(node.X, node.Y, node.Z))
# Fix the left side values
for node in self.model_part.Nodes:
if node.X < 0.001:
node.Fix(KratosMultiphysics.DISTANCE)
# Set the Trilinos linear solver and Epetra communicator
import trilinos_linear_solver_factory
trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver(
KratosMultiphysics.Parameters(
"""{"solver_type" : "AmesosSolver" }"""))
epetra_comm = TrilinosApplication.CreateCommunicator()
# Fake time advance
self.model_part.CloneTimeStep(40.0)
# Convect the distance field
TrilinosApplication.TrilinosLevelSetConvectionProcess2D(
epetra_comm, KratosMultiphysics.DISTANCE, self.model_part,
trilinos_linear_solver).Execute()
# Check the obtained values
max_distance = -1.0
min_distance = +1.0
for node in self.model_part.Nodes:
d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE)
max_distance = max(max_distance, d)
min_distance = min(min_distance, d)
min_distance = self.model_part.GetCommunicator().MinAll(min_distance)
max_distance = self.model_part.GetCommunicator().MaxAll(max_distance)
self.assertAlmostEqual(max_distance, 0.7904255118014996)
self.assertAlmostEqual(min_distance, -0.11710292469993094)
