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])
