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("A.mm"), K)
# Construct the solver
import eigen_solver_factory
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_condition_number(self):
space = KratosMultiphysics.UblasSparseSpace()
# Read the matrices
K = KratosMultiphysics.CompressedMatrix()
KratosMultiphysics.ReadMatrixMarketMatrix(GetFilePath("A.mm"), K)
# Construct the solver
import eigen_solver_factory
settings_max = KratosMultiphysics.Parameters("""
{
"eigen_solver_settings" : {
"solver_type" : "PowerIterationHighestEigenvalueSolver",
"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("""
{
"eigen_solver_settings" : {
"solver_type" : "PowerIterationEigenvalueSolver",
"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.assertAlmostEqual(condition_number, 194.5739, 3)
def _auxiliary_test_function(
self,
settings,
matrix_name="auxiliar_files_for_python_unnitest/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
import eigen_solver_factory
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 _auxiliary_test_function(self, settings, matrix_name="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
else:
M[i, j] = 0.0
# Construct the solver
import eigen_solver_factory
eigen_solver = eigen_solver_factory.ConstructSolver(settings)
# Solve
eigenvalue = eigen_solver.GetEigenValue(K, M)
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 test_mass_normalization(self):
space = KratosMultiphysics.UblasSparseSpace()
settings = KratosMultiphysics.Parameters('''{
"solver_type": "eigen_eigensystem",
"number_of_eigenvalues": 3,
"max_iteration": 1000,
"tolerance": 1e-8,
"normalize_eigenvectors": true,
"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", "A.mm")
KratosMultiphysics.ReadMatrixMarketMatrix(matrix_file_path, K) # symmetric test matrix
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 _create_linear_solver(self):
"""Create the eigensolver.
This overrides the base class method and replaces the usual linear solver
with an eigenvalue problem solver.
"""
import eigen_solver_factory
return eigen_solver_factory.ConstructSolver(self.eigensolver_settings)
def __init__(self, convergence_criterion_parameters):
# Note that all the convergence settings are introduced via a Kratos parameters object.
echo_level = convergence_criterion_parameters["echo_level"].GetInt()
convergence_criterion_name = convergence_criterion_parameters[
"convergence_criterion"].GetString()
if "contact" in 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()
condn_convergence_criterion = convergence_criterion_parameters[
"condn_convergence_criterion"].GetBool()
fancy_convergence_criterion = convergence_criterion_parameters[
"fancy_convergence_criterion"].GetBool()
print_convergence_criterion = convergence_criterion_parameters[
"print_convergence_criterion"].GetBool()
ensure_contact = convergence_criterion_parameters[
"ensure_contact"].GetBool()
gidio_debug = convergence_criterion_parameters[
"gidio_debug"].GetBool()
if (echo_level >= 1):
KM.Logger.PrintInfo(
"::[Mechanical Solver]:: ",
"CONVERGENCE CRITERION : " + convergence_criterion_name)
if (fancy_convergence_criterion == True):
table = KM.TableStreamUtility()
if (convergence_criterion_name == "contact_displacement_criterion"
):
if (fancy_convergence_criterion == True):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, D_RT, D_AT, ensure_contact, table,
print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, D_RT, D_AT, ensure_contact)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_criterion_name == "contact_residual_criterion"):
if (fancy_convergence_criterion == True):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact, table,
print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_criterion_name == "contact_mixed_criterion"):
if (fancy_convergence_criterion == True):
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact, table,
print_convergence_criterion)
else:
self.mechanical_convergence_criterion = CSMA.DisplacementLagrangeMultiplierMixedContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
elif (convergence_criterion_name == "contact_and_criterion"):
if (fancy_convergence_criterion == True):
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact, table,
print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact, table,
print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact)
Displacement.SetEchoLevel(echo_level)
Residual.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
Residual, Displacement)
elif (convergence_criterion_name == "contact_or_criterion"):
if (fancy_convergence_criterion == True):
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact, table,
print_convergence_criterion)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact, table,
print_convergence_criterion)
else:
Displacement = CSMA.DisplacementLagrangeMultiplierContactCriteria(
D_RT, D_AT, CD_RT, CD_AT, ensure_contact)
Residual = CSMA.DisplacementLagrangeMultiplierResidualContactCriteria(
R_RT, R_AT, CR_RT, CR_AT, ensure_contact)
Displacement.SetEchoLevel(echo_level)
Residual.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = KM.OrCriteria(
Residual, Displacement)
# Adding the mortar criteria
mortar_type = convergence_criterion_parameters[
"mortar_type"].GetString()
if (mortar_type == "ALMContactFrictionless"):
if (fancy_convergence_criterion == True):
Mortar = CSMA.ALMFrictionlessMortarConvergenceCriteria(
table, print_convergence_criterion, gidio_debug)
else:
Mortar = CSMA.ALMFrictionlessMortarConvergenceCriteria()
elif (mortar_type == "ALMContactFrictionlessComponents"):
if (fancy_convergence_criterion == True):
Mortar = CSMA.ALMFrictionlessComponentsMortarConvergenceCriteria(
table, print_convergence_criterion, gidio_debug)
else:
Mortar = CSMA.ALMFrictionlessComponentsMortarConvergenceCriteria(
)
elif (mortar_type == "ALMContactFrictional"):
if (fancy_convergence_criterion == True):
Mortar = CSMA.ALMFrictionalMortarConvergenceCriteria(
table, print_convergence_criterion, gidio_debug)
else:
Mortar = CSMA.ALMFrictionalMortarConvergenceCriteria()
elif ("MeshTying" in mortar_type):
if (fancy_convergence_criterion == True):
Mortar = CSMA.MeshTyingMortarConvergenceCriteria(table)
else:
Mortar = CSMA.MeshTyingMortarConvergenceCriteria()
Mortar.SetEchoLevel(echo_level)
if (fancy_convergence_criterion == True):
if (condn_convergence_criterion == True):
# Construct the solver
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, table,
print_convergence_criterion, condition_number_utility)
else:
self.mechanical_convergence_criterion = CSMA.MortarAndConvergenceCriteria(
self.mechanical_convergence_criterion, Mortar)
self.mechanical_convergence_criterion.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion.SetActualizeRHSFlag(True)
else: # Standard criteria (same as structural mechanics application)
# Construction of the class convergence_criterion
import convergence_criteria_factory
base_mechanical_convergence_criterion = convergence_criteria_factory.convergence_criterion(
convergence_criterion_parameters)
# Adding the mortar criteria
mortar_type = convergence_criterion_parameters[
"mortar_type"].GetString()
if (mortar_type == "ALMContactFrictionless"):
Mortar = CSMA.ALMFrictionlessMortarConvergenceCriteria()
Mortar.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
base_mechanical_convergence_criterion.
mechanical_convergence_criterion, Mortar)
(self.mechanical_convergence_criterion
).SetActualizeRHSFlag(True)
elif (mortar_type == "ALMContactFrictionless"):
Mortar = CSMA.ALMFrictionlessComponentsMortarConvergenceCriteria(
)
Mortar.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
base_mechanical_convergence_criterion.
mechanical_convergence_criterion, Mortar)
(self.mechanical_convergence_criterion
).SetActualizeRHSFlag(True)
elif (mortar_type == "ALMContactFrictional"):
Mortar = CSMA.ALMFrictionalMortarConvergenceCriteria()
Mortar.SetEchoLevel(echo_level)
self.mechanical_convergence_criterion = KM.AndCriteria(
base_mechanical_convergence_criterion.
mechanical_convergence_criterion, Mortar)
(self.mechanical_convergence_criterion
).SetActualizeRHSFlag(True)
elif ("MeshTying" in mortar_type):
Mortar = CSMA.MeshTyingMortarConvergenceCriteria()
Mortar.SetEchoLevel(echo_level)
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 __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
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
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
def ComputeConditionNumber(self):
NumberOfNodes = self.main_model_part.NumberOfNodes()
self.work_dir = '/home/inigo/simulations/naca0012/07_salome/05_MeshRefinement/'
#self.work_dir = '/home/inigo/simulations/naca0012/07_salome/06_Rectangle/'
Size1 = self.solver.GetSystemMatrix()
print('Size1 =', Size1.Size1())
if (NumberOfNodes < 5.0e1):
print('\nComputing condition number . . .\n')
import eigen_solver_factory
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)
condition_number = KratosMultiphysics.ConditionNumberUtility(
).GetConditionNumber(self.solver.GetSystemMatrix(),
eigen_solver_max, eigen_solver_min)
if (abs(condition_number - 1.0) < 1e-4):
print(
'Singular System. Not able to compute Condition Number. Zero EigenValue'
)
with open(self.work_dir + "mesh_refinement_loads.dat",
'a') as loads_file:
loads_file.write('%16s' % ("Zero Eigen"))
loads_file.flush()
with open(self.work_dir + "plots/results/all_cases.dat",
'a') as all_cases_file:
all_cases_file.write('%16s' % ("Zero Eigen"))
all_cases_file.flush()
else:
print('condition_number = {:.2e}'.format(condition_number))
with open(self.work_dir + "mesh_refinement_loads.dat",
'a') as loads_file:
loads_file.write('{0:16.2e}'.format(condition_number))
loads_file.flush()
with open(self.work_dir + "plots/results/all_cases.dat",
'a') as all_cases_file:
all_cases_file.write('{0:16.2e}'.format(condition_number))
all_cases_file.flush()
condition_results_file_name = self.work_dir + "plots/condition_number/data/condition/condition_results.dat"
with open(condition_results_file_name, 'a') as condition_file:
condition_file.write('{0:16.2e} {1:16.2e}\n'.format(
NumberOfNodes, condition_number))
condition_file.flush()
print('\nComputing condition number finished . . .\n')
else:
with open(self.work_dir + "mesh_refinement_loads.dat",
'a') as loads_file:
loads_file.write('%16s' % ("Not Comp."))
loads_file.flush()
with open(self.work_dir + "plots/results/all_cases.dat",
'a') as all_cases_file:
all_cases_file.write('%16s' % ("Not Comp."))
all_cases_file.flush()
