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