def _CreateConvergenceAccelerator(self): convergence_accelerator = convergence_accelerator_factory.CreateConvergenceAccelerator( self.settings["coupling_settings"]["coupling_strategy_settings"]) KratosMultiphysics.Logger.PrintInfo( "::[PartitionedFSIBaseSolver]::", "Coupling strategy construction finished.") return convergence_accelerator
def setUp(self): # Create a complete model part to retrieve an interface from it self.model = KratosMultiphysics.Model() model_part = self.model.CreateModelPart("MainModelPart") model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = 2 model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISPLACEMENT) # Import model part from mdpa file. work_folder = "FSIProblemEmulatorTest" input_filename = 'test_FSI_emulator_Structural' with UnitTest.WorkFolderScope(work_folder, __file__): KratosMultiphysics.ModelPartIO(input_filename).ReadModelPart( model_part) # Create the convergence accelerator conv_acc_factory = KratosMultiphysics.Parameters(""" { "solver_type": "constant_relaxation", "w": 0.5 }""") self.convergence_accelerator = convergence_accelerator_factory.CreateConvergenceAccelerator( conv_acc_factory) # Create the FSI coupling interface fsi_coupling_int_settings = KratosMultiphysics.Parameters(""" { "model_part_name": "FSICouplingInterfaceStructure", "parent_model_part_name": "MainModelPart.StructureInterface2D_Solid_interface", "input_variable_list": ["POSITIVE_FACE_PRESSURE"], "output_variable_list": ["DISPLACEMENT"] }""") self.fsi_coupling_interface = fsi_coupling_interface.FSICouplingInterface( self.model, fsi_coupling_int_settings, self.convergence_accelerator)
def test_aitken_accelerator(self): aitken_settings = KratosMultiphysics.Parameters("""{ "solver_type" : "Relaxation", "acceleration_type" : "Aitken", "w_0" : 0.825 }""") print("") print("Testing accelerator: ", aitken_settings["solver_type"].GetString()) # Construct the accelerator strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator( aitken_settings) x_guess = KratosMultiphysics.Vector(2) x_guess[0] = 0.5 x_guess[1] = 1.0 tol = 1e-14 max_it = 20 self.coupling_utility.Initialize() nl_it = 1 res_norm = 1.0 convergence = False self.coupling_utility.InitializeSolutionStep() while (nl_it <= max_it): residual = self.ComputeResidual(x_guess) res_norm = math.sqrt(residual[0]**2 + residual[1]**2) print("Iteration: ", nl_it, " residual norm: ", res_norm) if res_norm > tol: self.coupling_utility.InitializeNonLinearIteration() self.coupling_utility.UpdateSolution(residual, x_guess) self.coupling_utility.FinalizeNonLinearIteration() nl_it += 1 else: self.coupling_utility.FinalizeSolutionStep() convergence = True break x_final = x_guess # Check the obtained solution expected_x = KratosMultiphysics.Vector(2) expected_x[0] = math.sqrt(2) / 2.0 expected_x[1] = math.sqrt(2) / 2.0 if convergence == True: for i in range(0, len(expected_x)): self.assertAlmostEqual(expected_x[i], x_final[i])
def _create_convergence_accelerator(self): conv_acc_parameters = self.settings["coupling_settings"][ "convergence_accelerator_settings"] convergence_accelerator = convergence_accelerator_factory.CreateConvergenceAccelerator( conv_acc_parameters) KratosMultiphysics.Logger.PrintInfo( "::[ConjugateHeatTransferSolver]::", "Convergence accelerator construction finished.") return convergence_accelerator
def test_accelerator(self, force1, force2, solution, accelerator_settings): print("") print("Testing accelerator: ", accelerator_settings["solver_type"].GetString()) # Construct the accelerator strategy coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator( accelerator_settings) top_part = self.model_part.GetSubModelPart("Top") coupling_utility.Initialize() coupling_utility.InitializeSolutionStep() nl_it = 0 x_guess = self.InitializeGuess(top_part) residual = self.ComputeResidual(top_part, x_guess, force1, force2) res_norm = self.ComputeResidualNorm(residual) while (nl_it <= self.accelerator_iterations): if res_norm > self.accelerator_tolerance: coupling_utility.InitializeNonLinearIteration() coupling_utility.UpdateSolution(residual, x_guess) coupling_utility.FinalizeNonLinearIteration() else: coupling_utility.FinalizeSolutionStep() break nl_it += 1 residual = self.ComputeResidual(top_part, x_guess, force1, force2) res_norm = self.ComputeResidualNorm(residual) # Check the obtained solution expected_x = solution(top_part) if self.print_gid_output: self.PrintGuess(top_part, x_guess) for i in range(len(expected_x)): self.assertAlmostEqual(expected_x[i], x_guess[i], delta=self.assert_delta)
def _CreateConvergenceAccelerator(self): convergence_accelerator = convergence_accelerator_factory.CreateConvergenceAccelerator( self.settings["coupling_settings"]["coupling_strategy_settings"]) self._PrintInfoOnRankZero("::[PartitionedFSIBaseSolver]::", "Coupling strategy construction finished.") return convergence_accelerator
def test_accelerator_dx(self): settings = KratosMultiphysics.Parameters("""{ "solver_type" : "MVQN_recursive", "w_0" : 0.825 }""") print("") print("Testing Newton-Raphson with accelerator: ", settings["solver_type"].GetString(), " version with residual=DX") # Construct the coupling partitioned strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator( settings) x_guess = KratosMultiphysics.Vector(2) x_guess[0] = 0.5 x_guess[1] = 0.5 dx = KratosMultiphysics.Vector(2) dx[0] = 0.0 dx[1] = 0.0 tol = 1e-14 max_it = 20 acceleration = True if acceleration == True: self.coupling_utility.Initialize() nl_it = 1 res_norm = 1.0 convergence = False if acceleration == True: self.coupling_utility.InitializeSolutionStep() while (nl_it <= max_it): residual = self.ComputeResidual(x_guess) res_norm = math.sqrt(residual[0]**2 + residual[1]**2) print("Iteration: ", nl_it, " residual norm: ", res_norm) K = self.Jacobian(x_guess) Kinv = self.InvertMatrix(K) dx = self.prod(Kinv, residual) if res_norm > tol: #x_guess = x_guess + dx if acceleration == True: residual = dx #self.ComputeResidual(x_guess) self.coupling_utility.InitializeNonLinearIteration() self.coupling_utility.UpdateSolution(residual, x_guess) self.coupling_utility.FinalizeNonLinearIteration() residual = self.ComputeResidual(x_guess) res_norm = math.sqrt(residual[0]**2 + residual[1]**2) print("Iteration: ", nl_it, " residual norm after acceleration: ", res_norm) if res_norm < tol: if acceleration == True: self.coupling_utility.FinalizeSolutionStep() convergence = True break nl_it += 1 else: if acceleration == True: self.coupling_utility.FinalizeSolutionStep() convergence = True break x_final = x_guess # Check the obtained solution expected_x = KratosMultiphysics.Vector(2) expected_x[0] = math.sqrt(2) / 2.0 expected_x[1] = math.sqrt(2) / 2.0 if convergence == True: for i in range(0, len(expected_x)): self.assertAlmostEqual(expected_x[i], x_final[i])
def test_mvqn_recusive_accelerator(self): mvqn_recursive_settings = KratosMultiphysics.Parameters("""{ "solver_type" : "MVQN_recursive", "w_0" : 0.825, "buffer_size" : 7 }""") settings_list = [mvqn_recursive_settings] step = 1 tol = 1e-14 max_it = 20 recursive_steps = 10 x_guess = KratosMultiphysics.Vector(6) x_guess[0] = -20.0 * step / recursive_steps x_guess[1] = 20.0 * step / recursive_steps x_guess[2] = -5.0 * step / recursive_steps x_guess[3] = 15.0 * step / recursive_steps x_guess[4] = -25.0 * step / recursive_steps x_guess[5] = 30.0 * step / recursive_steps while (step <= recursive_steps): # Iterate throug the settings list for i in range(0, len(settings_list)): print("") print("Testing recursive accelerator: ", settings_list[i]["solver_type"].GetString(), " Step: ", step) # Construct the accelerator strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator( settings_list[i]) self.coupling_utility.Initialize() nl_it = 1 res_norm = 1.0 convergence = False self.coupling_utility.InitializeSolutionStep() while (nl_it <= max_it): residual = self.ComputeMVQNResidual( x_guess, step / recursive_steps) res_norm = math.sqrt(residual[0]**2 + residual[1]**2) print("Iteration: ", nl_it, " residual norm: ", res_norm) if res_norm > tol: self.coupling_utility.InitializeNonLinearIteration() self.coupling_utility.UpdateSolution(residual, x_guess) self.coupling_utility.FinalizeNonLinearIteration() nl_it += 1 else: self.coupling_utility.FinalizeSolutionStep() convergence = True break x_final = x_guess # Check the obtained solution expected_RHS = KratosMultiphysics.Vector(6) expected_RHS[0] = -3.49458887 * step / recursive_steps expected_RHS[1] = 11.98381557 * step / recursive_steps expected_RHS[2] = -9.42225393 * step / recursive_steps expected_RHS[3] = 3.79688473 * step / recursive_steps expected_RHS[4] = 0.72338935 * step / recursive_steps expected_RHS[5] = 4.36818068 * step / recursive_steps obtained_RHS = self.ComputeMVQNObtainededRHS(x_final) if convergence == True: for i in range(0, len(expected_RHS)): self.assertAlmostEqual(expected_RHS[i], obtained_RHS[i]) step += 1
def test_mvqn_accelerator(self): mvqn_settings = KratosMultiphysics.Parameters("""{ "solver_type" : "MVQN", "w_0" : 0.825 }""") print("") print("Testing accelerator: ", mvqn_settings["solver_type"].GetString()) # Construct the accelerator strategy self.coupling_utility = convergence_accelerator_factory.CreateConvergenceAccelerator( mvqn_settings) x_guess = KratosMultiphysics.Vector(6) x_guess[0] = -20.0 x_guess[1] = 20.0 x_guess[2] = -5.0 x_guess[3] = 15.0 x_guess[4] = -25.0 x_guess[5] = 30.0 tol = 5e-11 max_it = 20 self.coupling_utility.Initialize() nl_it = 1 convergence = False self.coupling_utility.InitializeSolutionStep() while (nl_it <= max_it): residual = self.ComputeMVQNResidual(x_guess) res_norm = 0.0 for i in range(0, len(residual)): res_norm += residual[i]**2 res_norm = math.sqrt(res_norm) print("Iteration: ", nl_it, " residual norm: ", res_norm) if res_norm > tol: self.coupling_utility.InitializeNonLinearIteration() self.coupling_utility.UpdateSolution(residual, x_guess) self.coupling_utility.FinalizeNonLinearIteration() nl_it += 1 else: self.coupling_utility.FinalizeSolutionStep() convergence = True break x_final = x_guess # Check the obtained solution expected_RHS = KratosMultiphysics.Vector(6) expected_RHS[0] = -3.49458887 expected_RHS[1] = 11.98381557 expected_RHS[2] = -9.42225393 expected_RHS[3] = 3.79688473 expected_RHS[4] = 0.72338935 expected_RHS[5] = 4.36818068 obtained_RHS = self.ComputeMVQNObtainededRHS(x_final) if convergence == True: for i in range(0, len(expected_RHS)): self.assertAlmostEqual(expected_RHS[i], obtained_RHS[i])