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 _solve_eigen(self, mp, echo=0):
feast_system_solver_settings = KratosMultiphysics.Parameters("""{ }""")
eigensolver_settings = KratosMultiphysics.Parameters("""
{
"perform_stochastic_estimate": false,
"lambda_min": 1.0e-2,
"lambda_max": 25.0,
"search_dimension": 7
}
""")
if not (hasattr(KratosMultiphysics.ExternalSolversApplication,
"PastixComplexSolver")):
self.skipTest('"PastixComplexSolver" not available')
feast_system_solver = ExternalSolversApplication.PastixComplexSolver(
feast_system_solver_settings)
eigen_solver = ExternalSolversApplication.FEASTSolver(
eigensolver_settings, feast_system_solver)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme(
)
eig_strategy = StructuralMechanicsApplication.EigensolverStrategy(
mp, eigen_scheme, builder_and_solver)
eig_strategy.SetEchoLevel(echo)
eig_strategy.Solve()
def _setup_harmonic_solver(self,mp,echo=0):
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(KratosMultiphysics.LinearSolver())
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
harmonic_strategy = StructuralMechanicsApplication.HarmonicAnalysisStrategy(mp, eigen_scheme, builder_and_solver, False)
harmonic_strategy.SetEchoLevel(echo)
return harmonic_strategy
def _solve_eigenvalue_problem(self, mp, use_block_builder, echo=0):
eigensolver_settings = KratosMultiphysics.Parameters("""
{
"max_iteration" : 1000,
"tolerance" : 1e-6,
"number_of_eigenvalues" : 2,
"echo_level" : 0,
"normalize_eigenvectors": true
}
""")
eigen_solver = LinearSolversApplication.EigensystemSolver(eigensolver_settings)
if use_block_builder:
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(eigen_solver)
else:
builder_and_solver = KratosMultiphysics.ResidualBasedEliminationBuilderAndSolver(eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
compute_modal_decomposition = True
# see "structural_mechanics_eigensolver.py", values are for the "EigensystemSolver"
mass_matrix_diagonal_value = 0.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,
compute_modal_decomposition)
eig_strategy.SetEchoLevel(echo)
eig_strategy.Solve()
def Initialize(self):
self.compute_model_part = self.GetComputeModelPart()
self.eigensolver_settings = self.settings["eigensolver_settings"]
if self.eigensolver_settings["solver_type"].GetString() == "FEAST":
linear_solver_settings = self.eigensolver_settings["linear_solver_settings"]
if linear_solver_settings["solver_type"].GetString() == "skyline_lu":
# default built-in feast system solver
self.eigen_solver = ExternalSolversApplication.FEASTSolver(self.eigensolver_settings)
else:
# external feast system solver
feast_system_solver = self._GetFEASTSystemSolver(linear_solver_settings)
self.eigen_solver = ExternalSolversApplication.FEASTSolver(self.eigensolver_settings, feast_system_solver)
else:
raise Exception("solver_type is not yet implemented: " + self.eigensolver_settings["solver_type"].GetString())
if self.settings["solution_type"].GetString() == "Dynamic":
self.scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
else:
raise Exception("solution_type is not yet implemented.")
self.builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(self.eigen_solver)
self.solver = StructuralMechanicsApplication.EigensolverStrategy(
self.compute_model_part,
self.scheme,
self.builder_and_solver)
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 test_undamped_mdof_system_eigen(self):
import KratosMultiphysics.ExternalSolversApplication as ExternalSolversApplication
# FEAST is available otherwise this test is not being called
if not hasattr(KratosMultiphysics.ExternalSolversApplication,
"PastixSolver"):
self.skipTest("Pastix Solver is not available")
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
eigen_solver_parameters = KratosMultiphysics.Parameters("""
{
"solver_type": "FEAST",
"print_feast_output": false,
"perform_stochastic_estimate": false,
"solve_eigenvalue_problem": true,
"lambda_min": 0.0,
"lambda_max": 4.0e5,
"number_of_eigenvalues": 2,
"search_dimension": 18,
"linear_solver_settings": {
"solver_type" : "pastix",
"echo_level" : 0
}
}""")
feast_system_solver = ExternalSolversApplication.PastixComplexSolver(
eigen_solver_parameters["linear_solver_settings"])
eigen_solver = ExternalSolversApplication.FEASTSolver(
eigen_solver_parameters, feast_system_solver)
scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(
eigen_solver)
solver = StructuralMechanicsApplication.EigensolverStrategy(
mp, scheme, builder_and_solver)
solver.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 _create_solution_scheme(self):
"""Create the scheme for the eigenvalue problem.
The scheme determines the left- and right-hand side matrices in the
generalized eigenvalue problem.
"""
if self.settings["solution_type"].GetString() == "Dynamic":
solution_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
else:
raise Exception("Unsupported solution_type: " + self.settings["solution_type"])
return solution_scheme
def _create_solution_scheme(self):
"""Create the scheme to construct the global force vector.
The scheme determines the initial force vector on all system dofs.
"""
if self.settings["scheme_type"].GetString() == "dynamic":
solution_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
else:
err_msg = "The requested scheme type \"" + scheme_type + "\" is not available!\n"
err_msg += "Available options are: \"dynamic\""
raise Exception(err_msg)
return solution_scheme
def _create_solution_scheme(self):
"""Create the scheme for the scipy solver.
The scheme determines the mass and stiffness matrices
"""
scheme_type = self.settings["scheme_type"].GetString()
if scheme_type == "dynamic":
solution_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
else: # here e.g. a stability scheme could be added
err_msg = "The requested scheme type \"" + scheme_type + "\" is not available!\n"
err_msg += "Available options are: \"dynamic\""
raise Exception(err_msg)
return solution_scheme
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 _create_solution_scheme(self):
"""Create the scheme for the eigenvalue problem.
The scheme determines the left- and right-hand side matrices in the
generalized eigenvalue problem.
"""
scheme_type = self.structural_eigensolver_settings[
"scheme_type"].GetString()
if scheme_type == "dynamic":
solution_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme(
)
else: # here e.g. a stability scheme could be added
err_msg = "The requested scheme type \"" + scheme_type + "\" is not available!\n"
err_msg += "Available options are: \"dynamic\""
raise Exception(err_msg)
return solution_scheme
def _solve_eigenvalue_problem(self,mp,echo=0):
eigensolver_settings = KratosMultiphysics.Parameters("""
{
"max_iteration" : 1000,
"tolerance" : 1e-6,
"number_of_eigenvalues" : 2,
"echo_level" : 3,
"normalize_eigenvectors": true
}
""")
eigen_solver = EigenSolversApplication.EigensystemSolver(eigensolver_settings)
builder_and_solver = KratosMultiphysics.ResidualBasedBlockBuilderAndSolver(eigen_solver)
eigen_scheme = StructuralMechanicsApplication.EigensolverDynamicScheme()
compute_modal_decomposition = True
eig_strategy = StructuralMechanicsApplication.EigensolverStrategy(mp,
eigen_scheme,
builder_and_solver,
compute_modal_decomposition)
eig_strategy.SetEchoLevel(echo)
eig_strategy.Solve()
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":
self.linear_solver = KratosExternal.FEASTSolver(self.eigensolver_settings)
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)
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 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])
