trilinos_tpetra_solver_direct.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 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_trilinos_tpetra_solver_direct_h
#define dealii_trilinos_tpetra_solver_direct_h
 
#include <deal.II/base/config.h>
 
#include "deal.II/grid/grid_generator.h"
 
#include "deal.II/lac/trilinos_tpetra_types.h"
 
#include <string>
 
#ifdef DEAL_II_TRILINOS_WITH_TPETRA
#  ifdef DEAL_II_TRILINOS_WITH_AMESOS2
 
#    include "deal.II/base/types.h"
 
#    include <deal.II/lac/la_parallel_vector.h>
#    include <deal.II/lac/solver_control.h>
#    include <deal.II/lac/trilinos_tpetra_sparse_matrix.h>
 
#    include <Amesos2.hpp>
#    include <Teuchos_ConfigDefs.hpp>
#    include <Teuchos_ParameterList.hpp>
#    include <Teuchos_RCPDecl.hpp>
 
 
DEAL_II_NAMESPACE_OPEN
 
namespace LinearAlgebra
{
  namespace TpetraWrappers
  {
    // forward declarations
#    ifndef DOXYGEN
    template <typename Number, typename MemorySpace>
    class SparseMatrix;
#    endif
 
    DeclException1(
      ExcTrilinosAmesos2SolverUnsupported,
      std::string,
      << "You tried to select the solver type <" << arg1 << ">\n"
      << "but this solver is not supported by Trilinos/Amesos2\n"
      << "due to one of the following reasons:\n"
      << "* This solver does not exist\n"
      << "* This solver is not (yet) supported by Trilinos/Amesos2\n"
      << "* Trilinos/Amesos2 was not configured for its use.");
 
 
    template <typename Number, typename MemorySpace = ::MemorySpace::Host>
    class SolverDirectBase
    {
    public:
      virtual ~SolverDirectBase() = default;
 
      void
      initialize(const SparseMatrix<Number, MemorySpace> &A);
 
      void
      solve(Vector<Number, MemorySpace>       &x,
            const Vector<Number, MemorySpace> &b);
 
      void
      solve(const SparseMatrix<Number, MemorySpace> &A,
            Vector<Number, MemorySpace>             &x,
            const Vector<Number, MemorySpace>       &b);
 
 
      SolverControl &
      control() const;
 
      DeclException1(ExcTrilinosError,
                     int,
                     << "An error with error number " << arg1
                     << " occurred while calling a Trilinos function");
 
    protected:
      SolverDirectBase(SolverControl &cn, const std::string &solver_type);
      void
      do_solve();
 
      SolverControl &solver_control;
 
      Teuchos::RCP<
        Amesos2::Solver<TpetraTypes::MatrixType<Number, MemorySpace>,
                        TpetraTypes::MultiVectorType<Number, MemorySpace>>>
        solver;
 
      /*
       * The set solver type to be handed to the solver factory of Amesos2.
       */
      std::string solver_type;
 
      Teuchos::ParameterList parameter_list;
    }; // Base
 
 
 
    template <typename Number, typename MemorySpace = ::MemorySpace::Host>
    class SolverDirect : public SolverDirectBase<Number, MemorySpace>
    {
    public:
      struct AdditionalData
      {
        AdditionalData(const std::string &solver_name);
 
 
        std::string solver_name;
      };
 
      SolverDirect(SolverControl        &cn,
                   const AdditionalData &additional_data = AdditionalData());
 
      void
      set_pararameter_list(Teuchos::ParameterList &parameter_list);
    }; // SolverDirect
 
 
    template <typename Number, typename MemorySpace = ::MemorySpace::Host>
    class SolverDirectKLU2 : public SolverDirectBase<Number, MemorySpace>
    {
    public:
      struct AdditionalData
      {
        AdditionalData(const std::string &transpose_mode       = "NOTRANS",
                       const bool         symmetric_mode       = false,
                       const bool         equilibrate_matrix   = true,
                       const std::string &column_permutation   = "COLAMD",
                       const std::string &iterative_refinement = "NO");
        std::string transpose_mode;
 
        bool symmetric_mode;
 
        bool equilibrate_matrix;
 
        std::string column_permutation;
 
        std::string iterative_refinement;
      };
 
      SolverDirectKLU2(
        SolverControl        &cn,
        const AdditionalData &additional_data = AdditionalData());
    }; // KLU2
 
  } // namespace TpetraWrappers
} // namespace LinearAlgebra
 
DEAL_II_NAMESPACE_CLOSE
 
#  endif // DEAL_II_TRILINOS_WITH_AMESOS2
#endif   // DEAL_II_TRILINOS_WITH_TPETRA
 
#endif