petsc_snes.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_petsc_snes_h
#define dealii_petsc_snes_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_PETSC
#  include <deal.II/base/mpi.h>
#  include <deal.II/base/observer_pointer.h>
#  include <deal.II/base/parameter_handler.h>
 
#  include <deal.II/lac/petsc_matrix_base.h>
#  include <deal.II/lac/petsc_precondition.h>
#  include <deal.II/lac/petsc_vector_base.h>
 
#  include <petscsnes.h>
 
#  include <exception>
 
#  if defined(DEAL_II_HAVE_CXX20)
#    include <concepts>
#  endif
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace PETScWrappers
{
  class NonlinearSolverData
  {
  public:
    using real_type = PetscReal;
 
    NonlinearSolverData(
      // Running parameters
      const std::string &options_prefix                = "",
      const std::string &snes_type                     = "",
      const std::string &snes_linesearch_type          = "",
      const real_type    absolute_tolerance            = 0,
      const real_type    relative_tolerance            = 0,
      const real_type    step_tolerance                = 0,
      const int          maximum_non_linear_iterations = -1,
      const int          max_n_function_evaluations    = -1)
      : options_prefix(options_prefix)
      , snes_type(snes_type)
      , snes_linesearch_type(snes_linesearch_type)
      , absolute_tolerance(absolute_tolerance)
      , relative_tolerance(relative_tolerance)
      , step_tolerance(step_tolerance)
      , maximum_non_linear_iterations(maximum_non_linear_iterations)
      , max_n_function_evaluations(max_n_function_evaluations)
    {}
 
    void
    add_parameters(ParameterHandler &prm);
 
    std::string options_prefix;
 
    std::string snes_type;
 
    std::string snes_linesearch_type;
 
    real_type absolute_tolerance;
 
    real_type relative_tolerance;
 
    real_type step_tolerance;
 
    int maximum_non_linear_iterations;
 
    int max_n_function_evaluations;
  };
 
  template <typename VectorType  = PETScWrappers::VectorBase,
            typename PMatrixType = PETScWrappers::MatrixBase,
            typename AMatrixType = PMatrixType>
  DEAL_II_CXX20_REQUIRES(
    (concepts::is_dealii_petsc_vector_type<VectorType> ||
     std::constructible_from<
       VectorType,
       Vec>)&&(concepts::is_dealii_petsc_matrix_type<PMatrixType> ||
               std::constructible_from<
                 PMatrixType,
                 Mat>)&&(concepts::is_dealii_petsc_matrix_type<AMatrixType> ||
                         std::constructible_from<AMatrixType, Mat>))
  class NonlinearSolver
  {
  public:
    using real_type = PetscReal;
 
    NonlinearSolver(const NonlinearSolverData &data     = NonlinearSolverData(),
                    const MPI_Comm             mpi_comm = PETSC_COMM_WORLD);
 
    ~NonlinearSolver();
 
    operator SNES() const;
 
    SNES
    petsc_snes();
 
    MPI_Comm
    get_mpi_communicator() const;
 
    void
    reinit();
 
    void
    reinit(const NonlinearSolverData &data);
 
    void
    set_matrix(PMatrixType &P);
 
    void
    set_matrices(AMatrixType &A, PMatrixType &P);
 
    unsigned int
    solve(VectorType &x);
 
    unsigned int
    solve(VectorType &x, PMatrixType &P);
 
    unsigned int
    solve(VectorType &x, AMatrixType &A, PMatrixType &P);
 
    std::function<void(const VectorType &x, VectorType &res)> residual;
 
    std::function<void(const VectorType &x, AMatrixType &A, PMatrixType &P)>
      jacobian;
 
    std::function<void(const VectorType  &x,
                       const unsigned int step_number,
                       const real_type    f_norm)>
      monitor;
 
    std::function<void(const VectorType &x)> setup_jacobian;
 
    std::function<void(const VectorType &src, VectorType &dst)>
      solve_with_jacobian;
 
    std::function<void(const VectorType &x, real_type &energy_value)> energy;
 
  private:
    SNES snes;
 
    ObserverPointer<AMatrixType, NonlinearSolver> A;
    ObserverPointer<PMatrixType, NonlinearSolver> P;
 
    bool need_dummy_assemble;
 
    mutable std::exception_ptr pending_exception;
  };
 
} // namespace PETScWrappers
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // DEAL_II_WITH_PETSC
 
#endif