trilinos_tpetra_solver_direct.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2024 - 2025 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>
 
DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#    include <Amesos2.hpp>
#    include <Teuchos_ConfigDefs.hpp>
#    include <Teuchos_ParameterList.hpp>
#    include <Teuchos_RCPDecl.hpp>
DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
 
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
#else
 
// Make sure the scripts that create the C++20 module input files have
// something to latch on if the preprocessor #ifdef above would
// otherwise lead to an empty content of the file.
DEAL_II_NAMESPACE_OPEN
DEAL_II_NAMESPACE_CLOSE
 
#endif // DEAL_II_TRILINOS_WITH_TPETRA
 
#endif