sunlinsol_wrapper.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2021 - 2024 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_sundials_sunlinsol_wrapper_h
#define dealii_sundials_sunlinsol_wrapper_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_SUNDIALS
 
#  include <sundials/sundials_linearsolver.h>
 
#  include <exception>
#  include <functional>
#  include <memory>
 
DEAL_II_NAMESPACE_OPEN
 
namespace SUNDIALS
{
#  ifndef DOXYGEN
  // forward declarations
  namespace internal
  {
    template <typename VectorType>
    struct LinearSolverContent;
  }
#  endif
 
  template <typename VectorType>
  struct SundialsOperator
  {
    void
    vmult(VectorType &dst, const VectorType &src) const;
 
#  if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
    SundialsOperator(void       *A_data,
                     SUNATimesFn a_times_fn,
                     SUNContext  linsol_ctx);
#  else
    SundialsOperator(void *A_data, ATimesFn a_times_fn);
#  endif
 
  private:
    void *A_data;
 
#  if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
    SUNATimesFn a_times_fn;
 
    SUNContext linsol_ctx;
#  else
    ATimesFn a_times_fn;
#  endif
  };
 
 
 
  template <typename VectorType>
  struct SundialsPreconditioner
  {
    void
    vmult(VectorType &dst, const VectorType &src) const;
 
#  if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
    SundialsPreconditioner(void       *P_data,
                           SUNPSolveFn p_solve_fn,
                           SUNContext  linsol_ctx,
                           double      tol);
#  else
    SundialsPreconditioner(void *P_data, PSolveFn p_solve_fn, double tol);
#  endif
 
  private:
    void *P_data;
 
#  if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
    SUNPSolveFn p_solve_fn;
 
    SUNContext linsol_ctx;
#  else
    PSolveFn p_solve_fn;
#  endif
 
    double tol;
  };
 
  template <typename VectorType>
  using LinearSolveFunction =
    std::function<void(SundialsOperator<VectorType>       &op,
                       SundialsPreconditioner<VectorType> &prec,
                       VectorType                         &x,
                       const VectorType                   &b,
                       double                              tol)>;
 
  namespace internal
  {
    template <typename VectorType>
    class LinearSolverWrapper
    {
    public:
      explicit LinearSolverWrapper(
        const LinearSolveFunction<VectorType> &lsolve,
        std::exception_ptr                    &pending_exception
#  if DEAL_II_SUNDIALS_VERSION_GTE(6, 0, 0)
        ,
        SUNContext linsol_ctx
#  endif
      );
 
      ~LinearSolverWrapper();
 
      operator SUNLinearSolver();
 
    private:
      SUNLinearSolver                                  sun_linear_solver;
      std::unique_ptr<LinearSolverContent<VectorType>> content;
    };
  } // namespace internal
} // namespace SUNDIALS
 
DEAL_II_NAMESPACE_CLOSE
 
#endif
#endif