trilinos_linear_operator.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) 2017 - 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_linear_operator_h
#define dealii_trilinos_linear_operator_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_TRILINOS
 
#  include <deal.II/lac/block_linear_operator.h>
#  include <deal.II/lac/linear_operator.h>
#  include <deal.II/lac/trilinos_tpetra_to_trilinos_wrappers.h>
 
#endif // DEAL_II_WITH_TRILINOS
 
DEAL_II_NAMESPACE_OPEN
 
#ifdef DEAL_II_WITH_TRILINOS
namespace TrilinosWrappers
{
  // Forward declarations:
#  ifndef DOXYGEN
  namespace internal
  {
    namespace LinearOperatorImplementation
    {
      class TrilinosPayload;
    }
 
    namespace BlockLinearOperatorImplementation
    {
      template <typename PayloadBlockType>
      class TrilinosBlockPayload;
    }
  } // namespace internal
#  endif
 
  template <typename Range, typename Domain = Range, typename Matrix>
  inline LinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
  linear_operator(const TrilinosWrappers::SparseMatrix &operator_exemplar,
                  const Matrix                         &matrix)
  {
    using OperatorExemplar = TrilinosWrappers::SparseMatrix;
    using Payload =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    return ::
      linear_operator<Range, Domain, Payload, OperatorExemplar, Matrix>(
        operator_exemplar, matrix);
  }
 
 
  template <typename Range, typename Domain = Range>
  inline LinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
  linear_operator(const TrilinosWrappers::SparseMatrix &matrix)
  {
    using Matrix = TrilinosWrappers::SparseMatrix;
    using Payload =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    return ::linear_operator<Range, Domain, Payload, Matrix, Matrix>(
      matrix, matrix);
  }
 
 
  template <typename Range, typename Domain, typename Matrix>
  inline LinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
  linear_operator(
    const LinearOperator<
      Range,
      Domain,
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload>
                 &operator_exemplar,
    const Matrix &matrix)
  {
    using Payload =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    using OperatorExemplar = LinearOperator<Range, Domain, Payload>;
    return ::
      linear_operator<Range, Domain, Payload, OperatorExemplar, Matrix>(
        operator_exemplar, matrix);
  }
 
 
  template <typename Range, typename Domain = Range>
  inline BlockLinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::BlockLinearOperatorImplementation::
      TrilinosBlockPayload<TrilinosWrappers::internal::
                             LinearOperatorImplementation::TrilinosPayload>>
  block_operator(const TrilinosWrappers::BlockSparseMatrix &block_matrix)
  {
    using BlockMatrix = TrilinosWrappers::BlockSparseMatrix;
    using PayloadBlockType =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    using BlockPayload = TrilinosWrappers::internal::
      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
    return ::block_operator<Range, Domain, BlockPayload, BlockMatrix>(
      block_matrix);
  }
 
 
  template <std::size_t m,
            std::size_t n,
            typename Range,
            typename Domain = Range>
  inline BlockLinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::BlockLinearOperatorImplementation::
      TrilinosBlockPayload<TrilinosWrappers::internal::
                             LinearOperatorImplementation::TrilinosPayload>>
  block_operator(
    const std::array<
      std::array<
        LinearOperator<typename Range::BlockType,
                       typename Domain::BlockType,
                       TrilinosWrappers::internal::
                         LinearOperatorImplementation::TrilinosPayload>,
        n>,
      m> &ops)
  {
    using PayloadBlockType =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    using BlockPayload = TrilinosWrappers::internal::
      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
    return ::block_operator<m, n, Range, Domain, BlockPayload>(ops);
  }
 
 
  template <typename Range, typename Domain = Range>
  inline BlockLinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::BlockLinearOperatorImplementation::
      TrilinosBlockPayload<TrilinosWrappers::internal::
                             LinearOperatorImplementation::TrilinosPayload>>
  block_diagonal_operator(
    const TrilinosWrappers::BlockSparseMatrix &block_matrix)
  {
    using BlockMatrix = TrilinosWrappers::BlockSparseMatrix;
    using PayloadBlockType =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    using BlockPayload = TrilinosWrappers::internal::
      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
    return ::
      block_diagonal_operator<Range, Domain, BlockPayload, BlockMatrix>(
        block_matrix);
  }
 
 
  template <std::size_t m, typename Range, typename Domain = Range>
  inline BlockLinearOperator<
    Range,
    Domain,
    TrilinosWrappers::internal::BlockLinearOperatorImplementation::
      TrilinosBlockPayload<TrilinosWrappers::internal::
                             LinearOperatorImplementation::TrilinosPayload>>
  block_diagonal_operator(
    const std::array<
      LinearOperator<typename Range::BlockType,
                     typename Domain::BlockType,
                     TrilinosWrappers::internal::LinearOperatorImplementation::
                       TrilinosPayload>,
      m> &ops)
  {
    using PayloadBlockType =
      TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload;
    using BlockPayload = TrilinosWrappers::internal::
      BlockLinearOperatorImplementation::TrilinosBlockPayload<PayloadBlockType>;
    return ::block_diagonal_operator<m, Range, Domain, BlockPayload>(ops);
  }
 
} // namespace TrilinosWrappers
 
#endif // DEAL_II_WITH_TRILINOS
 
DEAL_II_NAMESPACE_CLOSE
#endif