trilinos_tpetra_vector.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2018 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_trilinos_tpetra_vector_h
#define dealii_trilinos_tpetra_vector_h
 
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_TRILINOS_WITH_TPETRA
 
#  include <deal.II/base/index_set.h>
#  include <deal.II/base/mpi_stub.h>
#  include <deal.II/base/subscriptor.h>
 
#  include <deal.II/lac/trilinos_tpetra_communication_pattern.h>
#  include <deal.II/lac/vector_operation.h>
#  include <deal.II/lac/vector_space_vector.h>
#  include <deal.II/lac/vector_type_traits.h>
 
#  include <Teuchos_Comm.hpp>
#  include <Teuchos_OrdinalTraits.hpp>
#  include <Tpetra_Core.hpp>
#  include <Tpetra_Vector.hpp>
#  include <Tpetra_Version.hpp>
 
#  include <memory>
 
DEAL_II_NAMESPACE_OPEN
 
template <typename Number>
struct is_tpetra_type : std::false_type
{};
 
#  ifdef HAVE_TPETRA_INST_FLOAT
template <>
struct is_tpetra_type<float> : std::true_type
{};
#  endif
 
#  ifdef HAVE_TPETRA_INST_DOUBLE
template <>
struct is_tpetra_type<double> : std::true_type
{};
#  endif
 
#  ifdef DEAL_II_WITH_COMPLEX_VALUES
#    ifdef HAVE_TPETRA_INST_COMPLEX_FLOAT
template <>
struct is_tpetra_type<std::complex<float>> : std::true_type
{};
#    endif
 
#    ifdef HAVE_TPETRA_INST_COMPLEX_DOUBLE
template <>
struct is_tpetra_type<std::complex<double>> : std::true_type
{};
#    endif
#  endif
 
namespace LinearAlgebra
{
  // Forward declaration
#  ifndef DOXYGEN
  template <typename Number>
  class ReadWriteVector;
#  endif
 
  namespace TpetraWrappers
  {
    template <typename Number>
    class Vector : public VectorSpaceVector<Number>, public Subscriptor
    {
    public:
      using value_type = Number;
 
      using size_type = typename VectorSpaceVector<Number>::size_type;
 
      Vector();
 
      Vector(const Vector &V);
 
      explicit Vector(const IndexSet &parallel_partitioner,
                      const MPI_Comm  communicator);
 
      void
      reinit(const IndexSet &parallel_partitioner,
             const MPI_Comm  communicator,
             const bool      omit_zeroing_entries = false);
 
      virtual void
      reinit(const VectorSpaceVector<Number> &V,
             const bool omit_zeroing_entries = false) override;
 
      Vector &
      operator=(const Vector &V);
 
      virtual Vector &
      operator=(const Number s) override;
 
      virtual void
      import_elements(
        const ReadWriteVector<Number> &V,
        VectorOperation::values        operation,
        std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
          communication_pattern = {}) override;
 
      DEAL_II_DEPRECATED_EARLY
      virtual void
      import(const ReadWriteVector<Number> &V,
             VectorOperation::values        operation,
             std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
               communication_pattern = {}) override
      {
        import_elements(V, operation, communication_pattern);
      }
 
      virtual Vector &
      operator*=(const Number factor) override;
 
      virtual Vector &
      operator/=(const Number factor) override;
 
      virtual Vector &
      operator+=(const VectorSpaceVector<Number> &V) override;
 
      virtual Vector &
      operator-=(const VectorSpaceVector<Number> &V) override;
 
      virtual Number
      operator*(const VectorSpaceVector<Number> &V) const override;
 
      virtual void
      add(const Number a) override;
 
      virtual void
      add(const Number a, const VectorSpaceVector<Number> &V) override;
 
      virtual void
      add(const Number                     a,
          const VectorSpaceVector<Number> &V,
          const Number                     b,
          const VectorSpaceVector<Number> &W) override;
 
      virtual void
      sadd(const Number                     s,
           const Number                     a,
           const VectorSpaceVector<Number> &V) override;
 
      virtual void
      scale(const VectorSpaceVector<Number> &scaling_factors) override;
 
      virtual void
      equ(const Number a, const VectorSpaceVector<Number> &V) override;
 
      virtual bool
      all_zero() const override;
 
      virtual Number
      mean_value() const override;
 
      virtual typename LinearAlgebra::VectorSpaceVector<Number>::real_type
      l1_norm() const override;
 
      virtual typename LinearAlgebra::VectorSpaceVector<Number>::real_type
      l2_norm() const override;
 
      virtual typename LinearAlgebra::VectorSpaceVector<Number>::real_type
      linfty_norm() const override;
 
      virtual Number
      add_and_dot(const Number                     a,
                  const VectorSpaceVector<Number> &V,
                  const VectorSpaceVector<Number> &W) override;
      bool
      has_ghost_elements() const;
 
      virtual size_type
      size() const override;
 
      size_type
      locally_owned_size() const;
 
      MPI_Comm
      get_mpi_communicator() const;
 
      virtual ::IndexSet
      locally_owned_elements() const override;
 
      const Tpetra::Vector<Number, int, types::signed_global_dof_index> &
      trilinos_vector() const;
 
      Tpetra::Vector<Number, int, types::signed_global_dof_index> &
      trilinos_vector();
 
      virtual void
      print(std::ostream &     out,
            const unsigned int precision  = 3,
            const bool         scientific = true,
            const bool         across     = true) const override;
 
      virtual std::size_t
      memory_consumption() const override;
 
      DeclException0(ExcDifferentParallelPartitioning);
 
      DeclException0(ExcVectorTypeNotCompatible);
 
      DeclException1(ExcTrilinosError,
                     int,
                     << "An error with error number " << arg1
                     << " occurred while calling a Trilinos function");
 
    private:
      void
      create_tpetra_comm_pattern(const IndexSet &source_index_set,
                                 const MPI_Comm  mpi_comm);
 
      std::unique_ptr<
        Tpetra::Vector<Number, int, types::signed_global_dof_index>>
        vector;
 
      ::IndexSet source_stored_elements;
 
      std::shared_ptr<const TpetraWrappers::CommunicationPattern>
        tpetra_comm_pattern;
    };
 
 
    template <typename Number>
    inline bool
    Vector<Number>::has_ghost_elements() const
    {
      return false;
    }
  } // namespace TpetraWrappers
} // namespace LinearAlgebra
 
 
template <typename Number>
struct is_serial_vector<LinearAlgebra::TpetraWrappers::Vector<Number>>
  : std::false_type
{};
 
DEAL_II_NAMESPACE_CLOSE
 
#endif
 
#endif