def test_condition_number(self):
try:
import KratosMultiphysics.ExternalSolversApplication
except:
self.skipTest(
"KratosMultiphysics.ExternalSolversApplication is not available"
)
space = KratosMultiphysics.UblasSparseSpace()
# Read the matrices
K = KratosMultiphysics.CompressedMatrix()
KratosMultiphysics.ReadMatrixMarketMatrix(
GetFilePath(
"auxiliar_files_for_python_unnitest/sparse_matrix_files/A.mm"),
K)
# Construct the solver
settings_max = KratosMultiphysics.Parameters("""
{
"solver_type" : "power_iteration_highest_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0,
"linear_solver_settings" : {
"solver_type" : "SuperLUSolver",
"max_iteration" : 500,
"tolerance" : 1e-9,
"scaling" : false,
"verbosity" : 0
}
}
""")
eigen_solver_max = eigen_solver_factory.ConstructSolver(settings_max)
settings_min = KratosMultiphysics.Parameters("""
{
"solver_type" : "power_iteration_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0,
"linear_solver_settings" : {
"solver_type" : "SuperLUSolver",
"max_iteration" : 500,
"tolerance" : 1e-9,
"scaling" : false,
"verbosity" : 0
}
}
""")
eigen_solver_min = eigen_solver_factory.ConstructSolver(settings_min)
# Solve
condition_number_utility = KratosMultiphysics.ConditionNumberUtility()
condition_number = condition_number_utility.GetConditionNumber(
K, eigen_solver_max, eigen_solver_min)
self.assertLessEqual(abs(condition_number - 194.5739) / 194.5739, 1e-3)
def test_complex_symmetric_gev(self):
space = KratosMultiphysics.UblasComplexSparseSpace()
settings = KratosMultiphysics.Parameters('''{
"solver_type": "feast_complex",
"symmetric": true,
"number_of_eigenvalues": 3,
"e_mid_re": 0.0,
"e_mid_im": 0.0,
"e_r": 0.16,
"sort_eigenvalues": true,
"sort_order": "lm",
"echo_level": 0
}''')
K_real = KratosMultiphysics.CompressedMatrix()
this_file_dir = os.path.dirname(os.path.realpath(__file__))
base_dir = os.path.dirname(os.path.dirname(os.path.dirname(this_file_dir)))
matrix_file_path = os.path.join(base_dir, "kratos", "tests", "auxiliar_files_for_python_unittest", "sparse_matrix_files", "A.mm")
file_read = KratosMultiphysics.ReadMatrixMarketMatrix(matrix_file_path, K_real) # symmetric test matrix
self.assertTrue(file_read, msg="The matrix file could not be read")
K = KratosMultiphysics.ComplexCompressedMatrix(K_real)
K *= .1j
K += KratosMultiphysics.ComplexCompressedMatrix(K_real)
n = K.Size1()
self.assertEqual(n, 900)
# create an identity matrix
M = KratosMultiphysics.ComplexCompressedMatrix(n, n)
for i in range(n):
M[i, i] = 1.0
# create result containers (they will be resized inside the solver)
eigenvalues = KratosMultiphysics.ComplexVector(n)
eigenvectors = KratosMultiphysics.ComplexMatrix(n, 1)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigen_solver.Solve(K, M, eigenvalues, eigenvectors)
for i in range(eigenvalues.Size()):
eigenvector = KratosMultiphysics.ComplexVector(n)
for j in range(n):
eigenvector[j] = eigenvectors[i,j]
_aux_1 = KratosMultiphysics.ComplexVector(n,0)
_aux_2 = KratosMultiphysics.ComplexVector(n,0)
space.Mult(K,eigenvector,_aux_1)
space.Mult(M,eigenvector,_aux_2)
_aux_2 *= eigenvalues[i]
self.assertVectorAlmostEqual(_aux_1, _aux_2)
def _auxiliary_test_function(
self,
settings,
matrix_name="auxiliar_files_for_python_unittest/sparse_matrix_files/A.mm",
eigen_value_estimated="lowest"):
space = KratosMultiphysics.UblasSparseSpace()
# Read the matrices
K = KratosMultiphysics.CompressedMatrix()
KratosMultiphysics.ReadMatrixMarketMatrix(GetFilePath(matrix_name), K)
n = K.Size1()
M = KratosMultiphysics.CompressedMatrix(n, n)
for i in range(n):
for j in range(n):
if (i == j):
M[i, j] = 1.0
# create result containers (they will be resized inside the solver)
eigenvalues = KratosMultiphysics.Vector(n)
eigenvectors = KratosMultiphysics.Matrix(n, 1)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigen_solver.Solve(K, M, eigenvalues, eigenvectors)
eigenvalue = eigenvalues[0]
if (eigen_value_estimated == "lowest"):
self.assertLessEqual(abs(eigenvalue - 0.061463) / 0.061463, 5.0e-3)
else:
self.assertLessEqual(abs(eigenvalue - 11.959) / 11.959, 5.0e-3)
def _solve_eigen(self,mp,echo=0):
self.skipTestIfApplicationsNotAvailable("LinearSolversApplication")
from KratosMultiphysics import LinearSolversApplication
if not LinearSolversApplication.HasFEAST():
self.skipTest("FEAST is missing in the compilation")
eigensolver_settings = KratosMultiphysics.Parameters("""{
"solver_type": "feast",
"symmetric": true,
"e_min": 1.0e-2,
"e_max": 25.0,
"subspace_size": 7
}""")
eigen_solver = eigen_solver_factory.ConstructSolver(eigensolver_settings)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
mass_matrix_diagonal_value = 1.0
stiffness_matrix_diagonal_value = -1.0
eig_strategy = StructuralMechanicsApplication.EigensolverStrategy(mp,
eigen_scheme,
builder_and_solver,
mass_matrix_diagonal_value,
stiffness_matrix_diagonal_value)
eig_strategy.SetEchoLevel(echo)
eig_strategy.Solve()
def ExecuteInitializeSolutionStep(self):
# Get the model parts which divide the problem
current_process_info = self.model_part.ProcessInfo
# Compute the eigen values
eigen_linear_solver = eigen_solver_factory.ConstructSolver(
self.params["eigen_system_settings"])
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
eigen_linear_solver)
eigen_scheme = IGA.EigensolverNitscheStabilizationScheme()
eigen_solver = IGA.EigensolverNitscheStabilizationStrategy(
self.model_part, eigen_scheme, builder_and_solver)
eigen_solver.Solve()
# Compute the Nitsche stabilization factor
eigenvalue_nitsche_stabilization_vector = current_process_info.GetValue(
IGA.EIGENVALUE_NITSCHE_STABILIZATION_VECTOR)
nitsche_stabilization_factor = eigenvalue_nitsche_stabilization_vector[
eigenvalue_nitsche_stabilization_vector.Size() -
1] * 4 * self.params["number_of_conditions"].GetInt()
# Set the Nitsche stabilization factor
for prop in self.model_part_condition.Properties:
prop.SetValue(IGA.NITSCHE_STABILIZATION_FACTOR,
nitsche_stabilization_factor)
# Reset BUILD_LEVEL to calculate the continuity enforcement matrix in coupling Nitsche condition
self.model_part_condition.ProcessInfo.SetValue(IGA.BUILD_LEVEL, 0)
def _create_linear_solver(self):
"""Create the eigensolver.
This overrides the base class method and replaces the usual linear solver
with an eigenvalue problem solver.
"""
return eigen_solver_factory.ConstructSolver(self.settings["eigensolver_settings"])
def Initialize(self):
self.eigensolver_settings = self.settings["eigensolver_settings"]
solver_type = self.eigensolver_settings["solver_type"].GetString()
solution_type = self.settings["solution_type"].GetString()
if solver_type == "FEAST" or solver_type == "feast":
from KratosMultiphysics import eigen_solver_factory
self.linear_solver = eigen_solver_factory.ConstructSolver(
self.eigensolver_settings)
mass_matrix_diagonal_value = 1.0
stiffness_matrix_diagonal_value = -1.0
else:
raise Exception("solver_type is not yet implemented.")
if solution_type == "Dynamic":
self.scheme = KratosStructural.EigensolverDynamicScheme()
else:
raise Exception("solution_type is not yet implemented.")
self.builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
self.linear_solver)
self.solver = KratosStructural.EigensolverStrategy(
self.main_model_part, self.scheme, self.builder_and_solver,
mass_matrix_diagonal_value, stiffness_matrix_diagonal_value,
self.compute_modal_contribution)
def __init__(self, mp, settings):
"""Constructor of Utility-Object
Checks parameter settings and initializes the utility.
"""
default_settings = KratosMultiphysics.Parameters("""{
"eigensolver_settings" : {
"solver_type" : "eigen_eigensystem",
"max_iteration" : 1000,
"tolerance" : 1e-4,
"number_of_eigenvalues" : 100,
"normalize_eigenvectors" : false,
"echo_level" : 0
},
"perturbation_settings" : {
"max_displacement" : 1,
"correlation_length" : 100,
"truncation_error" : 1e-3,
"echo_level" : 0
}
}""")
settings.ValidateAndAssignDefaults(default_settings)
eigen_solver = eigen_solver_factory.ConstructSolver(
settings["eigensolver_settings"])
mp.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)
perturbation_settings = settings["perturbation_settings"]
# Initialize utility
self.utility = StructuralMechanicsApplication.PerturbGeometrySparseUtility(
mp, eigen_solver, perturbation_settings)
# Generate perturbation matrix
self.number_random_variables = self.utility.CreateRandomFieldVectors()
def test_real_general_gev_complex_result(self):
space = KratosMultiphysics.UblasComplexSparseSpace()
settings = KratosMultiphysics.Parameters('''{
"solver_type" : "feast",
"symmetric" : false,
"subspace_size" : 2,
"e_mid_re": 0.0,
"e_mid_im": 0.0,
"e_r": 30.0,
"sort_eigenvalues": true,
"sort_order": "li",
"echo_level": 0
}''')
K = KratosMultiphysics.CompressedMatrix(2, 2)
K[0, 0] = 1 / sqrt(2)
K[1, 1] = 1
n = K.Size1()
M = KratosMultiphysics.CompressedMatrix(n, n)
M[0, 1] = 1
M[1, 0] = -1 / sqrt(2)
# create result containers
eigenvalues = KratosMultiphysics.ComplexVector(n)
eigenvectors = KratosMultiphysics.ComplexMatrix(n, 1)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigen_solver.Solve(K, M, eigenvalues, eigenvectors)
self.assertAlmostEqual(eigenvalues[0], 0.0 + 1.0j, 7)
self.assertAlmostEqual(eigenvalues[1], 0.0 - 1.0j, 7)
Kc = KratosMultiphysics.ComplexCompressedMatrix(K)
Mc = KratosMultiphysics.ComplexCompressedMatrix(M)
for i in range(eigenvalues.Size()):
eigenvector = KratosMultiphysics.ComplexVector(n)
for j in range(n):
eigenvector[j] = eigenvectors[i, j]
_aux_1 = KratosMultiphysics.ComplexVector(n, 0)
_aux_2 = KratosMultiphysics.ComplexVector(n, 0)
space.Mult(Kc, eigenvector, _aux_1)
space.Mult(Mc, eigenvector, _aux_2)
_aux_2 *= eigenvalues[i]
self.assertVectorAlmostEqual(_aux_1, _aux_2)
def _run_test(self, settings):
space = KratosMultiphysics.UblasSparseSpace()
K = KratosMultiphysics.CompressedMatrix()
this_file_dir = os.path.dirname(os.path.realpath(__file__))
base_dir = os.path.dirname(
os.path.dirname(os.path.dirname(this_file_dir)))
matrix_file_path = os.path.join(base_dir, "kratos", "tests",
"auxiliar_files_for_python_unittest",
"sparse_matrix_files", "A.mm")
file_read = KratosMultiphysics.ReadMatrixMarketMatrix(
matrix_file_path, K) # symmetric test matrix
self.assertTrue(file_read, msg="The MatrixFile could not be read")
n = K.Size1()
self.assertEqual(n, 900)
M = KratosMultiphysics.CompressedMatrix(n, n)
for i in range(n):
for j in range(n):
if (i == j):
M[i, j] = 1.0
# create result containers (they will be resized inside the solver)
eigenvalues = KratosMultiphysics.Vector(n)
eigenvectors = KratosMultiphysics.Matrix(n, 1)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigen_solver.Solve(K, M, eigenvalues, eigenvectors)
self.assertAlmostEqual(eigenvalues[0], 0.061463, 4)
self.assertAlmostEqual(eigenvalues[1], 0.15318431112733275, 7)
self.assertAlmostEqual(eigenvalues[2], 0.153184311127333, 7)
# test mass normalization of eigenvectors
for i in range(eigenvectors.Size1()):
eigenvector = KratosMultiphysics.Vector(n)
for j in range(n):
eigenvector[j] = eigenvectors[i, j]
_aux = KratosMultiphysics.Vector(n)
space.Mult(M, eigenvector, _aux)
value = 0.0
for j in range(n):
value += eigenvector[j] * _aux[j]
self.assertAlmostEqual(value, 1.0, 7)
def test_eigen_dense_eigenvalue_solver(self):
eigensolver_settings = KratosMultiphysics.Parameters('''{
"solver_type" : "dense_eigensolver",
"ascending_order" : true,
"echo_level" : 0
}''')
# Construct matrix
n = 3
A = KratosMultiphysics.Matrix(n, n)
A[0, 0] = 3
A[0, 1] = 2
A[0, 2] = -1
A[1, 0] = 2
A[1, 1] = 10
A[1, 2] = 2
A[2, 0] = -1
A[2, 1] = 2
A[2, 2] = 3
# Create dummy matrix
Dummy = KratosMultiphysics.Matrix(n, n)
# Create result containers (they will be resized inside the solver)
eigenvalues = KratosMultiphysics.Vector(n)
eigenvectors = KratosMultiphysics.Matrix(n, n)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(
eigensolver_settings)
# Solve
eigen_solver.Solve(A, Dummy, eigenvalues, eigenvectors)
# Check eigenvalues
self.assertAlmostEqual(eigenvalues[0], 1.101020514433644, 8)
self.assertAlmostEqual(eigenvalues[1], 4.0, 8)
self.assertAlmostEqual(eigenvalues[2], 10.898979485566358, 8)
# Check eigenvectors
self.assertAlmostEqual(abs(eigenvectors[0, 0]), 0.673887338679049, 8)
self.assertAlmostEqual(abs(eigenvectors[1, 0]), 0.302905446527686, 8)
self.assertAlmostEqual(abs(eigenvectors[2, 0]), 0.673887338679049, 8)
self.assertAlmostEqual(abs(eigenvectors[0, 1]), 0.707106781186548, 8)
self.assertAlmostEqual(abs(eigenvectors[1, 1]), 0.0, 8)
self.assertAlmostEqual(abs(eigenvectors[2, 1]), 0.707106781186547, 8)
self.assertAlmostEqual(abs(eigenvectors[0, 2]), 0.214186495298066, 8)
self.assertAlmostEqual(abs(eigenvectors[1, 2]), 0.953020613871422, 8)
self.assertAlmostEqual(abs(eigenvectors[2, 2]), 0.214186495298066, 8)
def test_undamped_mdof_system_eigen(self):
current_model = KratosMultiphysics.Model()
mp = self._set_up_mdof_system(current_model)
#set parameters
mp.Elements[1].SetValue(KratosMultiphysics.NODAL_MASS, 20.0)
mp.Elements[2].SetValue(
StructuralMechanicsApplication.NODAL_DISPLACEMENT_STIFFNESS,
[200.0, 200.0, 200.0])
mp.Elements[3].SetValue(KratosMultiphysics.NODAL_MASS, 40.0)
mp.Elements[4].SetValue(
StructuralMechanicsApplication.NODAL_DISPLACEMENT_STIFFNESS,
[400.0, 400.0, 400.0])
#create solver
eigensolver_settings = KratosMultiphysics.Parameters("""{
"solver_type": "feast",
"symmetric": true,
"e_min": 0.0,
"e_max": 4.0e5,
"subspace_size": 18
}""")
eigen_solver = eigen_solver_factory.ConstructSolver(
eigensolver_settings)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme(
)
mass_matrix_diagonal_value = 1.0
stiffness_matrix_diagonal_value = -1.0
eig_strategy = StructuralMechanicsApplication.EigensolverStrategy(
mp, eigen_scheme, builder_and_solver, mass_matrix_diagonal_value,
stiffness_matrix_diagonal_value)
eig_strategy.Solve()
current_eigenvalues = [
ev for ev in mp.ProcessInfo[
StructuralMechanicsApplication.EIGENVALUE_VECTOR]
]
analytical_eigenvalues = [5, 20]
for ev in range(len(analytical_eigenvalues)):
self.assertAlmostEqual(current_eigenvalues[ev],
analytical_eigenvalues[ev])
def __init__(self, mp, settings):
"""Constructor of Utility-Object
Checks parameter settings and initializes the utility.
"""
default_settings = KratosMultiphysics.Parameters("""{
"eigensolver_settings" : {
"solver_type" : "dense_eigensolver",
"ascending_order" : false
},
"perturbation_settings" : {
"min_distance_subgrid" : 10,
"max_displacement" : 1,
"correlation_length" : 100,
"truncation_error" : 1e-3,
"echo_level" : 0
}
}""")
settings.ValidateAndAssignDefaults(default_settings)
eigensolver_settings = settings["eigensolver_settings"]
if (eigensolver_settings["ascending_order"].GetBool()):
warn_msg = 'Eigenvalues must be sorted in descending order. \n'
warn_msg += '''Parameter: '"ascending_order" : true' specification is ignored.'''
KratosMultiphysics.Logger.PrintWarning(
"PerturbGeometrySubgridUtility", warn_msg)
eigensolver_settings["ascending_order"].SetBool(False)
eigen_solver = eigen_solver_factory.ConstructSolver(
eigensolver_settings)
mp.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)
perturbation_settings = settings["perturbation_settings"]
# Initialize utility
self.utility = StructuralMechanicsApplication.PerturbGeometrySubgridUtility(
mp, eigen_solver, perturbation_settings)
# Generate perturbation matrix
self.number_random_variables = self.utility.CreateRandomFieldVectors()
def _solve_eigen(self, mp, echo=0):
eigensolver_settings = KratosMultiphysics.Parameters("""{
"solver_type": "feast",
"symmetric": true,
"e_min": 1.0e-2,
"e_max": 25.0,
"subspace_size": 7
}""")
eigen_solver = eigen_solver_factory.ConstructSolver(
eigensolver_settings)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme(
)
mass_matrix_diagonal_value = 1.0
stiffness_matrix_diagonal_value = -1.0
eig_strategy = StructuralMechanicsApplication.EigensolverStrategy(
mp, eigen_scheme, builder_and_solver, mass_matrix_diagonal_value,
stiffness_matrix_diagonal_value)
eig_strategy.SetEchoLevel(echo)
eig_strategy.Solve()
def __init__(self, model_part, convergence_criterion_parameters):
# The main model part
self.model_part = model_part
# Note that all the convergence settings are introduced via a Kratos parameters object.
self.echo_level = convergence_criterion_parameters[
"echo_level"].GetInt()
self.convergence_criterion_name = convergence_criterion_parameters[
"convergence_criterion"].GetString()
self.mortar_type = convergence_criterion_parameters[
"mortar_type"].GetString()
self.frictional_decomposed = convergence_criterion_parameters[
"frictional_decomposed"].GetBool()
self.print_convergence_criterion = convergence_criterion_parameters[
"print_convergence_criterion"].GetBool()
self.compute_dynamic_factor = convergence_criterion_parameters[
"compute_dynamic_factor"].GetBool()
self.gidio_debug = convergence_criterion_parameters[
"gidio_debug"].GetBool()
if "contact" in self.convergence_criterion_name:
D_RT = convergence_criterion_parameters[
"displacement_relative_tolerance"].GetDouble()
D_AT = convergence_criterion_parameters[
"displacement_absolute_tolerance"].GetDouble()
R_RT = convergence_criterion_parameters[
"residual_relative_tolerance"].GetDouble()
R_AT = convergence_criterion_parameters[
"residual_absolute_tolerance"].GetDouble()
CD_RT = convergence_criterion_parameters[
"contact_displacement_relative_tolerance"].GetDouble()
CD_AT = convergence_criterion_parameters[
"contact_displacement_absolute_tolerance"].GetDouble()
CR_RT = convergence_criterion_parameters[
"contact_residual_relative_tolerance"].GetDouble()
CR_AT = convergence_criterion_parameters[
"contact_residual_absolute_tolerance"].GetDouble()
FSTCD_RT = convergence_criterion_parameters[
"frictional_stick_contact_displacement_relative_tolerance"].GetDouble(
)
FSTCD_AT = convergence_criterion_parameters[
"frictional_stick_contact_displacement_absolute_tolerance"].GetDouble(
)
FSTCR_RT = convergence_criterion_parameters[
"frictional_stick_contact_residual_relative_tolerance"].GetDouble(
)
FSTCR_AT = convergence_criterion_parameters[
"frictional_stick_contact_residual_absolute_tolerance"].GetDouble(
)
FSLCD_RT = convergence_criterion_parameters[
"frictional_slip_contact_displacement_relative_tolerance"].GetDouble(
)
FSLCD_AT = convergence_criterion_parameters[
"frictional_slip_contact_displacement_absolute_tolerance"].GetDouble(
)
FSLCR_RT = convergence_criterion_parameters[
"frictional_slip_contact_residual_relative_tolerance"].GetDouble(
)
FSLCR_AT = convergence_criterion_parameters[
"frictional_slip_contact_residual_absolute_tolerance"].GetDouble(
)
RNTT = convergence_criterion_parameters[
"ratio_normal_tangent_threshold"].GetDouble()
condn_convergence_criterion = convergence_criterion_parameters[
"condn_convergence_criterion"].GetBool()
ensure_contact = convergence_criterion_parameters[
"ensure_contact"].GetBool()
if self.echo_level >= 1:
KM.Logger.PrintInfo(
"::[Mechanical Solver]:: ", "CONVERGENCE CRITERION : " +
self.convergence_criterion_name)
if self.convergence_criterion_name == "contact_displacement_criterion":
if "ALMContactFrictional" in self.mortar_type and self.frictional_decomposed:
if "PureSlip" in self.mortar_type:
pure_slip = True
else:
pure_slip = auxiliar_methods_solvers.AuxiliarPureSlipCheck(
self.model_part)
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierFrictionalContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, FSTCD_RT, FSTCD_AT, FSLCD_RT,
FSLCD_AT, RNTT, ensure_contact, pure_slip,
self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_residual_criterion":
if "ALMContactFrictional" in self.mortar_type and self.frictional_decomposed:
if "PureSlip" in self.mortar_type:
pure_slip = True
else:
pure_slip = auxiliar_methods_solvers.AuxiliarPureSlipCheck(
self.model_part)
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualFrictionalContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, FSTCD_RT, FSTCR_AT, FSLCD_RT,
FSLCR_AT, RNTT, ensure_contact, pure_slip,
self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_mixed_criterion":
if "ALMContactFrictional" in self.mortar_type and self.frictional_decomposed:
if "PureSlip" in self.mortar_type:
pure_slip = True
else:
pure_slip = auxiliar_methods_solvers.AuxiliarPureSlipCheck(
self.model_part)
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedFrictionalContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, FSTCD_RT, FSTCR_AT, FSLCD_RT,
FSLCR_AT, RNTT, ensure_contact, pure_slip,
self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_and_criterion":
if "Penalty" in self.mortar_type:
Displacement = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
Residual = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
Displacement.SetEchoLevel(self.echo_level)
Residual.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
Residual, Displacement)
elif self.convergence_criterion_name == "contact_or_criterion":
if "Penalty" in self.mortar_type:
Displacement = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
Residual = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
Displacement.SetEchoLevel(self.echo_level)
Residual.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion = KM.OrCriteria(
Residual, Displacement)
# Adding the mortar criteria
Mortar = self.GetMortarCriteria()
if condn_convergence_criterion:
# Construct the solver
settings_max = KM.Parameters("""
{
"solver_type" : "power_iteration_highest_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0
}
""")
eigen_solver_max = eigen_solver_factory.ConstructSolver(
settings_max)
settings_min = KM.Parameters("""
{
"solver_type" : "power_iteration_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0
}
""")
eigen_solver_min = eigen_solver_factory.ConstructSolver(
settings_min)
condition_number_utility = KM.ConditionNumberUtility(
eigen_solver_max, eigen_solver_min)
else:
condition_number_utility = None
self.mechanical_convergence_criterion = CSMA.MortarAndConvergenceCriteria(
self.mechanical_convergence_criterion, Mortar,
self.print_convergence_criterion, condition_number_utility)
self.mechanical_convergence_criterion.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion.SetActualizeRHSFlag(True)
elif self.convergence_criterion_name == "adaptative_remesh_criteria":
self.mechanical_convergence_criterion = None
else: # Standard criteria (same as structural mechanics application)
base_mechanical_convergence_criterion = convergence_criteria_factory.convergence_criterion(
convergence_criterion_parameters)
# Adding the mortar criteria
if "ALMContact" in self.mortar_type or "MeshTying" in self.mortar_type:
Mortar = self.GetMortarCriteria(False)
self.mechanical_convergence_criterion = KM.AndCriteria(
base_mechanical_convergence_criterion.
mechanical_convergence_criterion, Mortar)
self.mechanical_convergence_criterion.SetActualizeRHSFlag(True)
else:
self.mechanical_convergence_criterion = base_mechanical_convergence_criterion.mechanical_convergence_criterion
def test_real_general_gev(self):
space = KratosMultiphysics.UblasComplexSparseSpace()
settings = KratosMultiphysics.Parameters('''{
"solver_type": "feast",
"symmetric": false,
"number_of_eigenvalues": 3,
"e_mid_re": 10.0,
"e_mid_im": 0.0,
"e_r": 3.0,
"echo_level": 0
}''')
K = KratosMultiphysics.CompressedMatrix()
this_file_dir = os.path.dirname(os.path.realpath(__file__))
base_dir = os.path.dirname(
os.path.dirname(os.path.dirname(this_file_dir)))
matrix_file_path = os.path.join(base_dir, "kratos", "tests",
"auxiliar_files_for_python_unittest",
"sparse_matrix_files", "small_A.mm")
file_read = KratosMultiphysics.ReadMatrixMarketMatrix(
matrix_file_path, K) # symmetric test matrix
self.assertTrue(file_read, msg="The matrix file could not be read")
n = K.Size1()
# create an identity matrix
M = KratosMultiphysics.CompressedMatrix(n, n)
for i in range(n):
M[i, i] = 1
# create result containers (they will be resized inside the solver)
# eigenvalues and vectors of unsymmetric matrices are required to be real here
eigenvalues = KratosMultiphysics.ComplexVector(n)
eigenvectors = KratosMultiphysics.ComplexMatrix(n, 1)
# Construct the solver
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigen_solver.Solve(K, M, eigenvalues, eigenvectors)
self.assertEqual(eigenvalues.Size(), 2)
self.assertEqual(eigenvectors.Size1(), 2)
self.assertEqual(eigenvectors.Size2(), 5)
self.assertAlmostEqual(eigenvalues[0], 10.5, 7)
self.assertAlmostEqual(eigenvalues[1], 12.0, 7)
Kc = KratosMultiphysics.ComplexCompressedMatrix(K)
Mc = KratosMultiphysics.ComplexCompressedMatrix(M)
for i in range(eigenvalues.Size()):
eigenvector = KratosMultiphysics.ComplexVector(n)
for j in range(n):
eigenvector[j] = eigenvectors[i, j]
_aux_1 = KratosMultiphysics.ComplexVector(n, 0)
_aux_2 = KratosMultiphysics.ComplexVector(n, 0)
space.Mult(Kc, eigenvector, _aux_1)
space.Mult(Mc, eigenvector, _aux_2)
_aux_2 *= eigenvalues[i]
self.assertVectorAlmostEqual(_aux_1, _aux_2)
def _create_linear_solver_eigen(self):
"""Create the eigensolver"""
return eigen_solver_factory.ConstructSolver(
self.settings["eigensolver_settings"])
def ExecuteBeforeSolutionLoop(self):
""" This method is executed before starting the time loop
Keyword arguments:
self -- It signifies an instance of a class.
"""
# The general damping ratios
damping_ratio_0 = self.settings["damping_ratio_0"].GetDouble()
damping_ratio_1 = self.settings["damping_ratio_1"].GetDouble()
# We get the model parts which divide the problem
current_process_info = self.main_model_part.ProcessInfo
existing_computation = current_process_info.Has(SMA.EIGENVALUE_VECTOR)
# Create auxiliar parameters
compute_damping_coefficients_settings = KM.Parameters("""
{
"echo_level" : 0,
"damping_ratio_0" : 0.0,
"damping_ratio_1" : -1.0,
"eigen_values_vector" : [0.0]
}
""")
# Setting custom parameters
compute_damping_coefficients_settings["echo_level"].SetInt(
self.settings["echo_level"].GetInt())
compute_damping_coefficients_settings["damping_ratio_0"].SetDouble(
damping_ratio_0)
compute_damping_coefficients_settings["damping_ratio_1"].SetDouble(
damping_ratio_1)
# We check if the values are previously defined
properties = self.main_model_part.GetProperties()
for prop in properties:
if prop.Has(SMA.SYSTEM_DAMPING_RATIO):
self.settings["damping_ratio_0"].SetDouble(
prop.GetValue(SMA.SYSTEM_DAMPING_RATIO))
break
for prop in properties:
if prop.Has(SMA.SECOND_SYSTEM_DAMPING_RATIO):
self.settings["damping_ratio_1"].SetDouble(
prop.GetValue(SMA.SECOND_SYSTEM_DAMPING_RATIO))
break
# We have computed already the eigen values
current_process_info = self.main_model_part.ProcessInfo
precomputed_eigen_values = self.settings[
"eigen_values_vector"].GetVector()
if len(precomputed_eigen_values) > 1:
compute_damping_coefficients_settings[
"eigen_values_vector"].SetVector(precomputed_eigen_values)
else:
# If not computed eigen values already
if not existing_computation:
KM.Logger.PrintInfo(
"::[MechanicalSolver]::",
"EIGENVALUE_VECTOR not previously computed. Computing automatically, take care"
)
eigen_linear_solver = eigen_solver_factory.ConstructSolver(
self.settings["eigen_system_settings"])
builder_and_solver = KM.ResidualBasedBlockBuilderAndSolver(
eigen_linear_solver)
eigen_scheme = SMA.EigensolverDynamicScheme()
eigen_solver = SMA.EigensolverStrategy(self.main_model_part,
eigen_scheme,
builder_and_solver)
eigen_solver.Solve()
# Setting the variable RESET_EQUATION_IDS
current_process_info[SMA.RESET_EQUATION_IDS] = True
eigenvalue_vector = current_process_info.GetValue(
SMA.EIGENVALUE_VECTOR)
compute_damping_coefficients_settings[
"eigen_values_vector"].SetVector(eigenvalue_vector)
# We compute the coefficients
coefficients_vector = SMA.ComputeDampingCoefficients(
compute_damping_coefficients_settings)
# We set the values
if self.settings["write_on_properties"].GetBool():
for prop in self.main_model_part.Properties:
prop.SetValue(SMA.RAYLEIGH_ALPHA, coefficients_vector[0])
if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX):
if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]:
prop.SetValue(SMA.RAYLEIGH_BETA, 0.0)
else:
prop.SetValue(SMA.RAYLEIGH_BETA,
coefficients_vector[1])
else:
prop.SetValue(SMA.RAYLEIGH_BETA, coefficients_vector[1])
else:
current_process_info.SetValue(SMA.RAYLEIGH_ALPHA,
coefficients_vector[0])
if current_process_info.Has(KM.COMPUTE_LUMPED_MASS_MATRIX):
if current_process_info[KM.COMPUTE_LUMPED_MASS_MATRIX]:
current_process_info.SetValue(SMA.RAYLEIGH_BETA, 0.0)
else:
current_process_info.SetValue(SMA.RAYLEIGH_BETA,
coefficients_vector[1])
else:
current_process_info.SetValue(SMA.RAYLEIGH_BETA,
coefficients_vector[1])
def __init__(self, convergence_criterion_parameters):
# Note that all the convergence settings are introduced via a Kratos parameters object.
self.echo_level = convergence_criterion_parameters[
"echo_level"].GetInt()
self.convergence_criterion_name = convergence_criterion_parameters[
"convergence_criterion"].GetString()
self.mortar_type = convergence_criterion_parameters[
"mortar_type"].GetString()
self.frictional_decomposed = convergence_criterion_parameters[
"frictional_decomposed"].GetBool()
self.print_convergence_criterion = convergence_criterion_parameters[
"print_convergence_criterion"].GetBool()
self.compute_dynamic_factor = convergence_criterion_parameters[
"compute_dynamic_factor"].GetBool()
self.gidio_debug = convergence_criterion_parameters[
"gidio_debug"].GetBool()
if "contact" in self.convergence_criterion_name:
D_RT = convergence_criterion_parameters[
"displacement_relative_tolerance"].GetDouble()
D_AT = convergence_criterion_parameters[
"displacement_absolute_tolerance"].GetDouble()
R_RT = convergence_criterion_parameters[
"residual_relative_tolerance"].GetDouble()
R_AT = convergence_criterion_parameters[
"residual_absolute_tolerance"].GetDouble()
CD_RT = convergence_criterion_parameters[
"contact_displacement_relative_tolerance"].GetDouble()
CD_AT = convergence_criterion_parameters[
"contact_displacement_absolute_tolerance"].GetDouble()
CR_RT = convergence_criterion_parameters[
"contact_residual_relative_tolerance"].GetDouble()
CR_AT = convergence_criterion_parameters[
"contact_residual_absolute_tolerance"].GetDouble()
FCD_RT = convergence_criterion_parameters[
"frictional_contact_displacement_relative_tolerance"].GetDouble(
)
FCD_AT = convergence_criterion_parameters[
"frictional_contact_displacement_absolute_tolerance"].GetDouble(
)
FCR_RT = convergence_criterion_parameters[
"frictional_contact_residual_relative_tolerance"].GetDouble()
FCR_AT = convergence_criterion_parameters[
"frictional_contact_residual_absolute_tolerance"].GetDouble()
condn_convergence_criterion = convergence_criterion_parameters[
"condn_convergence_criterion"].GetBool()
ensure_contact = convergence_criterion_parameters[
"ensure_contact"].GetBool()
if self.echo_level >= 1:
KM.Logger.PrintInfo(
"::[Mechanical Solver]:: ", "CONVERGENCE CRITERION : " +
self.convergence_criterion_name)
if self.convergence_criterion_name == "contact_displacement_criterion":
if (self.mortar_type == "ALMContactFrictional"
and self.frictional_decomposed):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierFrictionalContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, FCD_RT, FCD_AT,
ensure_contact, self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_residual_criterion":
if (self.mortar_type == "ALMContactFrictional"
and self.frictional_decomposed):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualFrictionalContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, FCR_RT, FCR_AT,
ensure_contact, self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_mixed_criterion":
if (self.mortar_type == "ALMContactFrictional"
and self.frictional_decomposed):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedFrictionalontactCriteria(
R_RT, R_AT, CR_RT, CR_AT, FCR_RT, FCR_AT,
ensure_contact, self.print_convergence_criterion)
elif "Penalty" in self.mortar_type:
self.mechanical_convergence_criterion = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
self.mechanical_convergence_criterion.SetEchoLevel(
self.echo_level)
elif self.convergence_criterion_name == "contact_and_criterion":
if "Penalty" in self.mortar_type:
Displacement = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
Residual = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
Displacement.SetEchoLevel(self.echo_level)
Residual.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
Residual, Displacement)
elif self.convergence_criterion_name == "contact_or_criterion":
if "Penalty" in self.mortar_type:
Displacement = CSMA.DisplacementContactCriteria(
D_RT, D_AT, self.print_convergence_criterion)
Residual = CSMA.DisplacementResidualContactCriteria(
R_RT, R_AT, self.print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact,
self.print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact,
self.print_convergence_criterion)
Displacement.SetEchoLevel(self.echo_level)
Residual.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion = KM.OrCriteria(
Residual, Displacement)
# Adding the mortar criteria
Mortar = self.GetMortarCriteria()
if (condn_convergence_criterion is True):
# Construct the solver
from KratosMultiphysics import eigen_solver_factory
settings_max = KM.Parameters("""
{
"solver_type" : "power_iteration_highest_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0,
"linear_solver_settings" : {
"solver_type" : "SuperLUSolver",
"max_iteration" : 500,
"tolerance" : 1e-9,
"scaling" : false,
"verbosity" : 0
}
}
""")
eigen_solver_max = eigen_solver_factory.ConstructSolver(
settings_max)
settings_min = KM.Parameters("""
{
"solver_type" : "power_iteration_eigenvalue_solver",
"max_iteration" : 10000,
"tolerance" : 1e-9,
"required_eigen_number" : 1,
"verbosity" : 0,
"linear_solver_settings" : {
"solver_type" : "SuperLUSolver",
"max_iteration" : 500,
"tolerance" : 1e-9,
"scaling" : false,
"verbosity" : 0
}
}
""")
eigen_solver_min = eigen_solver_factory.ConstructSolver(
settings_min)
condition_number_utility = KM.ConditionNumberUtility(
eigen_solver_max, eigen_solver_min)
else:
condition_number_utility = None
self.mechanical_convergence_criterion = CSMA.MortarAndConvergenceCriteria(
self.mechanical_convergence_criterion, Mortar,
self.print_convergence_criterion, condition_number_utility)
self.mechanical_convergence_criterion.SetEchoLevel(self.echo_level)
self.mechanical_convergence_criterion.SetActualizeRHSFlag(True)
elif self.convergence_criterion_name == "adaptative_remesh_criteria":
self.mechanical_convergence_criterion = None
else: # Standard criteria (same as structural mechanics application)
# Construction of the class convergence_criterion
from KratosMultiphysics.StructuralMechanicsApplication import convergence_criteria_factory
base_mechanical_convergence_criterion = convergence_criteria_factory.convergence_criterion(
convergence_criterion_parameters)
# Adding the mortar criteria
if "ALMContact" in self.mortar_type or "MeshTying" in self.mortar_type:
Mortar = self.GetMortarCriteria(False)
self.mechanical_convergence_criterion = KM.AndCriteria(
base_mechanical_convergence_criterion.
mechanical_convergence_criterion, Mortar)
self.mechanical_convergence_criterion.SetActualizeRHSFlag(True)
else:
self.mechanical_convergence_criterion = base_mechanical_convergence_criterion.mechanical_convergence_criterion
