From ab7356d2c2652f593362c9d29c754ce545192624 Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Tue, 9 May 2023 10:48:16 -0600 Subject: [PATCH] Add a test that checks NOX error handling. --- tests/trilinos/nox_solver_04.cc | 140 ++++++++++++++++++ ...lver_04.with_trilinos_with_nox=true.output | 24 +++ 2 files changed, 164 insertions(+) create mode 100644 tests/trilinos/nox_solver_04.cc create mode 100644 tests/trilinos/nox_solver_04.with_trilinos_with_nox=true.output diff --git a/tests/trilinos/nox_solver_04.cc b/tests/trilinos/nox_solver_04.cc new file mode 100644 index 0000000000..de1cfec3c5 --- /dev/null +++ b/tests/trilinos/nox_solver_04.cc @@ -0,0 +1,140 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2022 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// Check TrilinosWrappers::NOXSolver. This test solves the same +// problem as nox_solver_03, but it throws an exception in one of the +// user functions. The test checks that we capture and rethrow the +// exception, and that we can ultimately catch it. + + +#include + +#include + +#include + +// as reference solution +#include +#include +#include +#include + +#include "../tests.h" + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1); + + using Number = double; + using VectorType = Vector; + + // set up solver control + const unsigned int n_max_iterations = 100; + const double abs_tolerance = 1e-9; + const double rel_tolerance = 1e-5; + const double lin_rel_tolerance = 1e-3; + + TrilinosWrappers::NOXSolver::AdditionalData additional_data( + n_max_iterations, abs_tolerance, rel_tolerance); + + // set up parameters + Teuchos::RCP non_linear_parameters = + Teuchos::rcp(new Teuchos::ParameterList); + + non_linear_parameters->set("Nonlinear Solver", "Line Search Based"); + non_linear_parameters->sublist("Printing").set("Output Information", 15); + non_linear_parameters->sublist("Direction").set("Method", "Newton"); + non_linear_parameters->sublist("Direction") + .sublist("Newton") + .sublist("Linear Solver") + .set("Tolerance", lin_rel_tolerance); + non_linear_parameters->sublist("Line Search").set("Method", "Polynomial"); + + + // set up solver + TrilinosWrappers::NOXSolver solver(additional_data, + non_linear_parameters); + + // ... helper functions + solver.residual = [](const VectorType &u, VectorType &F) { + deallog << "Evaluating the solution at u=(" << u[0] << ',' << u[1] << ')' + << std::endl; + + F(0) = std::cos(u[0] + u[1]) - 1 + 2 * u[0]; + F(1) = std::sin(u[0] - u[1]) + 2 * u[1]; + + throw ExcMessage("Irrecoverable failure."); + }; + + FullMatrix J(2, 2); + FullMatrix J_inverse(2, 2); + + solver.setup_jacobian = [&J, &J_inverse](const VectorType &u) { + // We don't do any kind of set-up in this program, but we can at least + // say that we're here + deallog << "Setting up Jacobian system at u=(" << u[0] << ',' << u[1] << ')' + << std::endl; + + J(0, 0) = -std::sin(u[0] + u[1]) + 2; + J(0, 1) = -std::sin(u[0] + u[1]); + J(1, 0) = std::cos(u[0] - u[1]); + J(1, 1) = -std::cos(u[0] - u[1]) + 2; + + J_inverse.invert(J); + }; + + solver.apply_jacobian = [&](const VectorType &src, VectorType &dst) { + J.vmult(dst, src); + }; + + solver.solve_with_jacobian = [&J_inverse](const VectorType &rhs, + VectorType & dst, + const double /*tolerance*/) { + deallog << "Solving Jacobian system with rhs=(" << rhs[0] << ',' << rhs[1] + << ')' << std::endl; + + J_inverse.vmult(dst, rhs); + }; + + // initial guess + const unsigned int N = 2; + VectorType solution(N); + solution[0] = 0.5; + solution[1] = 1.234; + + // solve with the given initial guess + try + { + auto niter = solver.solve(solution); + solution.print(deallog.get_file_stream()); + deallog << "Converged in " << niter << " iterations." << std::endl; + } + catch (const std::exception &exc) + { + deallog << "Caught an irrecoverable exception in a callback:" << std::endl + << exc.what() << std::endl; + } + catch (const char *s) + { + deallog << "Trilinos threw its own exception of type char*:" << std::endl + << s << std::endl; + } +} diff --git a/tests/trilinos/nox_solver_04.with_trilinos_with_nox=true.output b/tests/trilinos/nox_solver_04.with_trilinos_with_nox=true.output new file mode 100644 index 0000000000..4f4e0d744e --- /dev/null +++ b/tests/trilinos/nox_solver_04.with_trilinos_with_nox=true.output @@ -0,0 +1,24 @@ + +DEAL::Evaluating the solution at u=(0.500000,1.23400) +DEAL::Caught an irrecoverable exception in a callback: +DEAL:: +-------------------------------------------------------- +An error occurred in line <0> of file <> in function + +The violated condition was: + +Additional information: + NOX aborted with an error text of after a user callback + function had thrown an exception with the following message: + + -------------------------------------------------------- + An error occurred in line <0> of file <> in function + + The violated condition was: + + Additional information: + Irrecoverable failure. + -------------------------------------------------------- + +-------------------------------------------------------- + -- 2.39.5