def __init__(self, model_part, project_parameters, do_pre_recovery=False):
L2_projection_recoverer.L2ProjectionMaterialAccelerationRecoverer.__init__(
self, project_parameters, model_part)
Pouliot2012GradientRecoverer.__init__(self, project_parameters,
model_part)
self.do_pre_recovery = do_pre_recovery
scheme = Kratos.ResidualBasedIncrementalUpdateStaticScheme()
amgcl_smoother = Kratos.AMGCLSmoother.SPAI0
amgcl_krylov_type = Kratos.AMGCLIterativeSolverType.BICGSTAB_WITH_GMRES_FALLBACK
tolerance = 1e-12
max_iterations = 200
verbosity = 2 # 0->shows no information, 1->some information, 2->all the information
gmres_size = 400
if self.use_lumped_mass_matrix:
linear_solver = Kratos.CGSolver()
else:
linear_solver = Kratos.AMGCLSolver(amgcl_smoother,
amgcl_krylov_type, tolerance,
max_iterations, verbosity,
gmres_size)
self.recovery_strategy = Kratos.ResidualBasedDerivativeRecoveryStrategy(
self.recovery_model_part, scheme, linear_solver, False, True,
False, False)
self.recovery_strategy.SetEchoLevel(0)
def CreateCPluPlusStrategies(self, echo_level=1):
# from KratosMultiphysics.ExternalSolversApplication import SuperLUIterativeSolver
# from KratosMultiphysics.ExternalSolversApplication import SuperLUSolver
# linear_solver = SuperLUIterativeSolver()
scheme = Kratos.ResidualBasedIncrementalUpdateStaticScheme()
amgcl_smoother = Kratos.AMGCLSmoother.SPAI0
amgcl_krylov_type = Kratos.AMGCLIterativeSolverType.BICGSTAB_WITH_GMRES_FALLBACK
tolerance = 1e-8
max_iterations = 400
verbosity = 2 #0->shows no information, 1->some information, 2->all the information
gmres_size = 400
# if self.use_lumped_mass_matrix:
# linear_solver = CGSolver()
# else:
linear_solver = Kratos.AMGCLSolver(amgcl_smoother, amgcl_krylov_type,
tolerance, max_iterations,
verbosity, gmres_size)
# linear_solver = SuperLUIterativeSolver()
# linear_solver = CGSolver()
# linear_solver = SkylineLUFactorizationSolver()
# linear_solver = SuperLUSolver()
# linear_solver = ITSOL_ARMS_Solver()
# linear_solver = MKLPardisoSolver()
# linear_solver = AMGCLSolver(amgcl_smoother, amgcl_krylov_type, tolerance, max_iterations, verbosity,gmres_size)
self.recovery_strategy = Kratos.ResidualBasedDerivativeRecoveryStrategy(
self.recovery_model_part, scheme, linear_solver, False, False,
False, False)
self.recovery_strategy.SetEchoLevel(echo_level)
def _setup_solver(self, solving_with="Block", linear_solver="AMGCL"):
#define a minimal newton raphson solver
if linear_solver == "AMGCL":
self.linear_solver = KM.AMGCLSolver()
else:
self.linear_solver = KM.SkylineLUFactorizationSolver()
if solving_with == "Block":
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
else: # Block default
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.scheme = KM.ResidualBasedBossakDisplacementScheme(-0.01)
self.convergence_criterion = KM.ResidualCriteria(1e-6, 1e-9)
self.convergence_criterion.SetEchoLevel(0)
max_iters = 10
compute_reactions = True
reform_step_dofs = True
move_mesh_flag = False
self.strategy = KM.ResidualBasedNewtonRaphsonStrategy(
self.mp, self.scheme, self.linear_solver,
self.convergence_criterion, self.builder_and_solver, max_iters,
compute_reactions, reform_step_dofs, move_mesh_flag)
self.strategy.SetEchoLevel(0)
self.strategy.Initialize()
self.strategy.Check()
def SetStrategy(self):
scheme = KratosMultiphysics.ResidualBasedIncrementalUpdateStaticScheme(
)
linear_solver = KratosMultiphysics.AMGCLSolver()
self.l2_projector_strategy = KratosMultiphysics.ResidualBasedLinearStrategy(
self.error_model_part, scheme, linear_solver, False, False, False,
False)
def _create_linear_solver(self):
linear_solver = super(ContactImplicitMechanicalSolver,
self)._create_linear_solver()
if (self.contact_settings["rescale_linear_solver"].GetBool() is True):
linear_solver = KM.ScalingSolver(linear_solver, False)
mortar_type = self.contact_settings["mortar_type"].GetString()
if (mortar_type == "ALMContactFrictional"
or mortar_type == "ALMContactFrictionlessComponents"):
if (self.contact_settings["use_mixed_ulm_solver"].GetBool() == True
):
self.print_on_rank_zero(
"::[Contact Mechanical Implicit Dynamic Solver]:: ",
"Using MixedULMLinearSolver, definition of ALM parameters recommended"
)
name_mixed_solver = self.contact_settings[
"mixed_ulm_solver_parameters"]["solver_type"].GetString()
if (name_mixed_solver == "mixed_ulm_linear_solver"):
linear_solver_name = self.settings[
"linear_solver_settings"]["solver_type"].GetString()
if (linear_solver_name == "AMGCL"
or linear_solver_name == "AMGCLSolver"):
amgcl_param = KM.Parameters("""
{
"solver_type" : "AMGCL",
"smoother_type" : "ilu0",
"krylov_type" : "lgmres",
"coarsening_type" : "aggregation",
"max_iteration" : 100,
"provide_coordinates" : false,
"gmres_krylov_space_dimension" : 100,
"verbosity" : 1,
"tolerance" : 1e-6,
"scaling" : false,
"block_size" : 3,
"use_block_matrices_if_possible" : true,
"coarse_enough" : 500
}
""")
amgcl_param["block_size"].SetInt(
self.main_model_part.ProcessInfo[KM.DOMAIN_SIZE])
self.linear_solver_settings.RecursivelyValidateAndAssignDefaults(
amgcl_param)
linear_solver = KM.AMGCLSolver(
self.linear_solver_settings)
mixed_ulm_solver = CSMA.MixedULMLinearSolver(
linear_solver,
self.contact_settings["mixed_ulm_solver_parameters"])
return mixed_ulm_solver
else:
self.print_on_rank_zero(
"::[Contact Mechanical Implicit Dynamic Solver]:: ",
"Mixed solver not available: " + name_mixed_solver +
". Using not mixed linear solver")
return linear_solver
else:
return linear_solver
else:
return linear_solver
def __init__(self, model_part, custom_settings):
self.main_model_part = model_part
##settings string in json format
default_settings = KratosMultiphysics.Parameters("""
{
"solver_type" : "dam_P_solver",
"model_import_settings" : {
"input_type" : "mdpa",
"input_filename" : "unknown_name",
"input_file_label" : 0
},
"echo_level" : 1,
"buffer_size" : 2,
"processes_sub_model_part_list" : [""],
"acoustic_solver_settings" : {
"strategy_type" : "Newton-Raphson",
"scheme_type" : "Newmark",
"convergence_criterion" : "Residual_criterion",
"residual_relative_tolerance" : 0.0001,
"residual_absolute_tolerance" : 1e-9,
"max_iteration" : 10,
"move_mesh_flag" : false,
"echo_level" : 0,
"linear_solver_settings" : {
"solver_type" : "amgcl",
"max_iteration" : 200,
"tolerance" : 1e-7,
"verbosity" : 0,
"GMRES_size" : 50
}
}
}""")
##overwrite the default settings with user-provided parameters
self.settings = custom_settings
self.settings.ValidateAndAssignDefaults(default_settings)
## Definition of the linear solver
amgcl_smoother = KratosMultiphysics.AMGCLSmoother.ILU0
amgcl_krylov_type = KratosMultiphysics.AMGCLIterativeSolverType.BICGSTAB
tolerance = self.settings["acoustic_solver_settings"][
"linear_solver_settings"]["tolerance"].GetDouble()
max_iterations = self.settings["acoustic_solver_settings"][
"linear_solver_settings"]["max_iteration"].GetInt()
verbosity = self.settings["acoustic_solver_settings"][
"linear_solver_settings"]["verbosity"].GetInt()
gmres_size = self.settings["acoustic_solver_settings"][
"linear_solver_settings"]["GMRES_size"].GetInt()
self.linear_solver = KratosMultiphysics.AMGCLSolver(
amgcl_smoother, amgcl_krylov_type, tolerance, max_iterations,
verbosity, gmres_size)
def AuxiliarCreateLinearSolver(main_model_part, settings, contact_settings, linear_solver_settings, linear_solver):
if contact_settings["rescale_linear_solver"].GetBool():
linear_solver = KM.ScalingSolver(linear_solver, False)
mortar_type = contact_settings["mortar_type"].GetString()
if "ALMContactFrictional" in mortar_type or mortar_type == "ALMContactFrictionlessComponents":
if contact_settings["use_mixed_ulm_solver"].GetBool():
KM.Logger.PrintInfo("::[Contact Mechanical Solver]:: ", "Using MixedULMLinearSolver, definition of ALM parameters recommended")
name_mixed_solver = contact_settings["mixed_ulm_solver_parameters"]["solver_type"].GetString()
if name_mixed_solver == "mixed_ulm_linear_solver":
if settings.Has("linear_solver_settings"):
if settings["linear_solver_settings"].Has("solver_type"):
linear_solver_name = settings["linear_solver_settings"]["solver_type"].GetString()
if linear_solver_name == "amgcl" or linear_solver_name == "AMGCL" or linear_solver_name == "AMGCLSolver":
amgcl_param = KM.Parameters("""
{
"solver_type" : "amgcl",
"smoother_type" : "ilu0",
"krylov_type" : "lgmres",
"coarsening_type" : "aggregation",
"max_iteration" : 100,
"provide_coordinates" : false,
"gmres_krylov_space_dimension" : 100,
"verbosity" : 1,
"tolerance" : 1e-6,
"scaling" : false,
"block_size" : 3,
"use_block_matrices_if_possible" : true,
"coarse_enough" : 500
}
""")
amgcl_param["block_size"].SetInt(main_model_part.ProcessInfo[KM.DOMAIN_SIZE])
linear_solver_settings.RecursivelyValidateAndAssignDefaults(amgcl_param)
linear_solver = KM.AMGCLSolver(linear_solver_settings)
mixed_ulm_solver = CSMA.MixedULMLinearSolver(linear_solver, contact_settings["mixed_ulm_solver_parameters"])
return mixed_ulm_solver
else:
return linear_solver
else:
return linear_solver
else:
KM.Logger.PrintInfo("::[Contact Mechanical Solver]:: ", "Mixed solver not available: " + name_mixed_solver + ". Using not mixed linear solver")
return linear_solver
else:
return linear_solver
else:
return linear_solver
def _setup_solver(self, solving_with="Block", linear_solver="AMGCL"):
#define a minimal newton raphson solver
if linear_solver == "AMGCL":
self.linear_solver = KM.AMGCLSolver()
else:
self.linear_solver = KM.SkylineLUFactorizationSolver()
if solving_with == "Block":
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
elif solving_with == "LM":
params = KM.Parameters("""{
"diagonal_values_for_dirichlet_dofs" : "use_max_diagonal",
"silent_warnings" : false,
"consider_lagrange_multiplier_constraint_resolution" : "single"
}""")
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolverWithLagrangeMultiplier(
self.linear_solver, params)
elif solving_with == "DoubleLM":
params = KM.Parameters("""{
"diagonal_values_for_dirichlet_dofs" : "use_max_diagonal",
"silent_warnings" : false,
"consider_lagrange_multiplier_constraint_resolution" : "double"
}""")
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolverWithLagrangeMultiplier(
self.linear_solver, params)
else: # Block default
self.builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.scheme = KM.ResidualBasedBossakDisplacementScheme(-0.01)
self.convergence_criterion = KM.ResidualCriteria(1e-6, 1e-9)
self.convergence_criterion.SetEchoLevel(0)
max_iters = 10
compute_reactions = True
reform_step_dofs = True
move_mesh_flag = False
self.strategy = KM.ResidualBasedNewtonRaphsonStrategy(
self.mp, self.scheme, self.convergence_criterion,
self.builder_and_solver, max_iters, compute_reactions,
reform_step_dofs, move_mesh_flag)
self.strategy.SetEchoLevel(0)
self.strategy.Initialize()
self.strategy.Check()
def CreateCPluPlusStrategies(self, echo_level=1):
from KratosMultiphysics.ExternalSolversApplication import SuperLUIterativeSolver
# linear_solver = SuperLUIterativeSolver()
# from KratosMultiphysics.ExternalSolversApplication import SuperLUSolver
scheme = Kratos.ResidualBasedIncrementalUpdateStaticScheme()
amgcl_smoother = Kratos.AMGCLSmoother.ILU0
amgcl_krylov_type = Kratos.AMGCLIterativeSolverType.BICGSTAB
tolerance = 1e-8
max_iterations = 1000
verbosity = 0 #0->shows no information, 1->some information, 2->all the information
gmres_size = 50
if self.use_lumped_mass_matrix:
linear_solver = SuperLUIterativeSolver()
else:
linear_solver = Kratos.AMGCLSolver(amgcl_smoother,
amgcl_krylov_type, tolerance,
max_iterations, verbosity,
gmres_size)
self.recovery_strategy = Kratos.ResidualBasedDerivativeRecoveryStrategy(
self.recovery_model_part, scheme, linear_solver, False, True,
False, False)
self.recovery_strategy.SetEchoLevel(echo_level)
def ConstructSolver(configuration):
import KratosMultiphysics
if (type(configuration) != KratosMultiphysics.Parameters):
raise Exception(
"input is expected to be provided as a Kratos Parameters object")
solver_type = configuration["solver_type"].GetString()
if configuration.Has("scaling"):
scaling = configuration["scaling"].GetBool()
else:
scaling = False
if (solver_type == "CGSolver"):
linear_solver = KratosMultiphysics.CGSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "BICGSTABSolver"):
linear_solver = KratosMultiphysics.BICGSTABSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "TFQMRSolver"):
linear_solver = KratosMultiphysics.TFQMRSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "DeflatedCGSolver"):
linear_solver = KratosMultiphysics.DeflatedCGSolver(configuration)
elif (solver_type == "MixedUPLinearSolver"):
linear_solver = KratosMultiphysics.MixedUPLinearSolver(configuration)
elif (solver_type == "SkylineLUFactorizationSolver"):
linear_solver = KratosMultiphysics.SkylineLUFactorizationSolver(
configuration)
elif (solver_type == "complex_skyline_lu_solver"):
linear_solver = KratosMultiphysics.ComplexSkylineLUSolver(
configuration)
################################## following solvers need importing the ExternalSolversApplication
elif (solver_type == "GMRESSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.GMRESSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "SuperLUSolver" or solver_type == "Super LU"
or solver_type == "Super_LU"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.SuperLUSolver(
configuration)
elif (solver_type == "SuperLUIterativeSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.SuperLUIterativeSolver(
configuration)
elif (solver_type == "PastixSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.PastixSolver(
configuration)
elif (solver_type == "AMGCL"):
linear_solver = KratosMultiphysics.AMGCLSolver(configuration)
elif (solver_type == "AMGCL_NS_Solver"):
linear_solver = KratosMultiphysics.AMGCL_NS_Solver(configuration)
elif (solver_type == "complex_pastix_solver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.PastixComplexSolver(
configuration)
################################## following solvers need importing the EigenSolversApplication
elif (solver_type == "eigen_sparse_lu"):
import KratosMultiphysics.EigenSolversApplication
linear_solver = KratosMultiphysics.EigenSolversApplication.SparseLUSolver(
configuration)
elif (solver_type == "eigen_pardiso_llt"): # needs Intel MKL
import KratosMultiphysics.EigenSolversApplication
linear_solver = KratosMultiphysics.EigenSolversApplication.PardisoLLTSolver(
configuration)
elif (solver_type == "eigen_pardiso_ldlt"): # needs Intel MKL
import KratosMultiphysics.EigenSolversApplication
linear_solver = KratosMultiphysics.EigenSolversApplication.PardisoLDLTSolver(
configuration)
elif (solver_type == "eigen_pardiso_lu"): # needs Intel MKL
import KratosMultiphysics.EigenSolversApplication
linear_solver = KratosMultiphysics.EigenSolversApplication.PardisoLUSolver(
configuration)
# emulating the solvers of the MKLSolversApplication through the EigenSolversApplication
elif (solver_type == "ParallelMKLPardisoSolver"):
KratosMultiphysics.Logger.PrintWarning(
"LinearSolverFactor", "Solver Parallel_MKL_Pardiso is deprecated,\
please use it through the EigenSolversApplication (see the Readme in the Application)"
)
import KratosMultiphysics.EigenSolversApplication
linear_solver = KratosMultiphysics.EigenSolversApplication.PardisoLUSolver(
configuration)
###################################### FAILED TO FIND solver_type
else:
raise Exception("solver type not found. Asking for :" + solver_type)
###### here decide if a prescaling is to be applied
if (scaling == False):
return linear_solver
else:
return KratosMultiphysics.ScalingSolver(linear_solver, True)
def ConstructSolver(configuration):
import KratosMultiphysics
if (type(configuration) != KratosMultiphysics.Parameters):
raise Exception(
"input is expected to be provided as a Kratos Parameters object")
solver_type = configuration["solver_type"].GetString()
if configuration.Has("scaling"):
scaling = configuration["scaling"].GetBool()
else:
scaling = False
if (solver_type == "CGSolver"):
linear_solver = KratosMultiphysics.CGSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "BICGSTABSolver"):
linear_solver = KratosMultiphysics.BICGSTABSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "TFQMRSolver"):
linear_solver = KratosMultiphysics.TFQMRSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "DeflatedCGSolver"):
linear_solver = KratosMultiphysics.DeflatedCGSolver(configuration)
elif (solver_type == "MixedUPLinearSolver"):
linear_solver = KratosMultiphysics.MixedUPLinearSolver(configuration)
elif (solver_type == "SkylineLUFactorizationSolver"):
linear_solver = KratosMultiphysics.SkylineLUFactorizationSolver(
configuration)
elif (solver_type == "complex_skyline_lu_solver"):
linear_solver = KratosMultiphysics.ComplexSkylineLUSolver(
configuration)
################################## following solvers need importing the ExternalSolversApplication
elif (solver_type == "GMRESSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.GMRESSolver(
configuration, ConstructPreconditioner(configuration))
elif (solver_type == "SuperLUSolver" or solver_type == "Super LU"
or solver_type == "Super_LU"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.SuperLUSolver(
configuration)
elif (solver_type == "SuperLUIterativeSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.SuperLUIterativeSolver(
configuration)
elif (solver_type == "PastixSolver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.PastixSolver(
configuration)
elif (solver_type == "AMGCL"):
linear_solver = KratosMultiphysics.AMGCLSolver(configuration)
elif (solver_type == "AMGCL_NS_Solver"):
linear_solver = KratosMultiphysics.AMGCL_NS_Solver(configuration)
elif (solver_type == "complex_pastix_solver"):
import KratosMultiphysics.ExternalSolversApplication
linear_solver = KratosMultiphysics.ExternalSolversApplication.PastixComplexSolver(
configuration)
################################## following solvers need importing the MKLSolversApplication
elif (solver_type == "ParallelMKLPardisoSolver"):
import KratosMultiphysics.MKLSolversApplication
linear_solver = KratosMultiphysics.MKLSolversApplication.ParallelMKLPardisoSolver(
configuration)
###################################### FAILED TO FIND solver_type
else:
raise Exception("solver type not found. Asking for :" + solver_type)
###### here decide if a prescaling is to be applied
if (scaling == False):
return linear_solver
else:
return KratosMultiphysics.ScalingSolver(linear_solver, True)
