nox.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2022 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_trilinos_nox_h
#define dealii_trilinos_nox_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_TRILINOS_WITH_NOX
 
#  include <deal.II/base/exceptions.h>
 
#  include <deal.II/lac/solver_control.h>
 
#  include <Teuchos_ParameterList.hpp>
 
#  include <exception>
#  include <functional>
 
#endif
 
DEAL_II_NAMESPACE_OPEN
 
#ifdef DEAL_II_TRILINOS_WITH_NOX
namespace TrilinosWrappers
{
  // Indicate that NOXSolver has not converged.
  DeclException0(ExcNOXNoConvergence);
 
 
  template <typename VectorType>
  class NOXSolver
  {
  public:
    struct AdditionalData
    {
      enum class NormType
      {
        L1,
        L2,
        Linfty,
      };
 
      enum class NormScaling
      {
        Unscaled,
        Scaled
      };
 
    public:
      AdditionalData(const unsigned int max_iter                       = 10,
                     const double       abs_tol                        = 1.e-20,
                     const double       rel_tol                        = 1.e-5,
                     const unsigned int threshold_nonlinear_iterations = 1,
                     const unsigned int threshold_n_linear_iterations  = 0,
                     const bool         reuse_solver                   = false,
                     const NormType     norm_type    = NormType::L2,
                     const NormScaling  norm_scaling = NormScaling::Scaled);
 
      unsigned int max_iter;
 
      double abs_tol;
 
      NormType norm_type;
 
      NormScaling norm_scaling;
 
      double rel_tol;
 
      unsigned int threshold_nonlinear_iterations;
 
      unsigned int threshold_n_linear_iterations;
 
      bool reuse_solver;
    };
 
    NOXSolver(AdditionalData                             &additional_data,
              const Teuchos::RCP<Teuchos::ParameterList> &parameters =
                Teuchos::rcp(new Teuchos::ParameterList));
 
    ~NOXSolver();
 
    void
    clear();
 
    unsigned int
    solve(VectorType &solution);
 
    std::function<void(const VectorType &u, VectorType &F)> residual;
 
    std::function<void(const VectorType &current_u)> setup_jacobian;
 
    std::function<void(const VectorType &current_u)> setup_preconditioner;
 
    std::function<void(const VectorType &x, VectorType &y)> apply_jacobian;
 
    std::function<
      void(const VectorType &y, VectorType &x, const double tolerance)>
      solve_with_jacobian;
 
    std::function<
      int(const VectorType &y, VectorType &x, const double tolerance)>
      solve_with_jacobian_and_track_n_linear_iterations;
 
    std::function<SolverControl::State(const unsigned int i,
                                       const double       norm_f,
                                       const VectorType  &current_u,
                                       const VectorType  &f)>
      check_iteration_status;
 
    std::function<bool()> update_preconditioner_predicate;
 
  private:
    AdditionalData additional_data;
 
    const Teuchos::RCP<Teuchos::ParameterList> parameters;
 
    unsigned int n_residual_evaluations;
 
    unsigned int n_jacobian_applications;
 
    unsigned int n_nonlinear_iterations;
 
    unsigned int n_last_linear_iterations;
 
    mutable std::exception_ptr pending_exception;
  };
} // namespace TrilinosWrappers
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
 
#endif