trilinos_epetra_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2015 - 2019 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_epetra_vector_h
#define dealii_trilinos_epetra_vector_h


#include <deal.II/base/config.h>

#if defined(DEAL_II_WITH_TRILINOS) && defined(DEAL_II_WITH_MPI)

#  include <deal.II/base/index_set.h>
#  include <deal.II/base/subscriptor.h>

#  include <deal.II/lac/trilinos_epetra_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 <Epetra_FEVector.h>
#  include <mpi.h>

#  include <memory>

DEAL_II_NAMESPACE_OPEN

namespace LinearAlgebra
{
  // Forward declaration
  template <typename Number>
  class ReadWriteVector;

  namespace EpetraWrappers
  {
    class Vector : public VectorSpaceVector<double>, public Subscriptor
    {
    public:
      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<double> &V,
             const bool omit_zeroing_entries = false) override;

      Vector &
      operator=(const Vector &V);

      virtual Vector &
      operator=(const double s) override;

      virtual void
      import(
        const ReadWriteVector<double> &                 V,
        VectorOperation::values                         operation,
        std::shared_ptr<const CommunicationPatternBase> communication_pattern =
          std::shared_ptr<const CommunicationPatternBase>()) override;

      virtual Vector &
      operator*=(const double factor) override;

      virtual Vector &
      operator/=(const double factor) override;

      virtual Vector &
      operator+=(const VectorSpaceVector<double> &V) override;

      virtual Vector &
      operator-=(const VectorSpaceVector<double> &V) override;

      virtual double
      operator*(const VectorSpaceVector<double> &V) const override;

      virtual void
      add(const double a) override;

      virtual void
      add(const double a, const VectorSpaceVector<double> &V) override;

      virtual void
      add(const double                     a,
          const VectorSpaceVector<double> &V,
          const double                     b,
          const VectorSpaceVector<double> &W) override;

      virtual void
      sadd(const double                     s,
           const double                     a,
           const VectorSpaceVector<double> &V) override;

      virtual void
      scale(const VectorSpaceVector<double> &scaling_factors) override;

      virtual void
      equ(const double a, const VectorSpaceVector<double> &V) override;

      virtual bool
      all_zero() const override;

      virtual double
      mean_value() const override;

      virtual double
      l1_norm() const override;

      virtual double
      l2_norm() const override;

      virtual double
      linfty_norm() const override;

      virtual double
      add_and_dot(const double                     a,
                  const VectorSpaceVector<double> &V,
                  const VectorSpaceVector<double> &W) override;
      bool
      has_ghost_elements() const;

      virtual size_type
      size() const override;

      MPI_Comm
      get_mpi_communicator() const;

      virtual ::IndexSet
      locally_owned_elements() const override;

      const Epetra_FEVector &
      trilinos_vector() const;

      Epetra_FEVector &
      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_epetra_comm_pattern(const IndexSet &source_index_set,
                                 const MPI_Comm &mpi_comm);

      std::unique_ptr<Epetra_FEVector> vector;

      ::IndexSet source_stored_elements;

      std::shared_ptr<const CommunicationPattern> epetra_comm_pattern;
    };


    inline bool
    Vector::has_ghost_elements() const
    {
      return false;
    }
  } // namespace EpetraWrappers
} // namespace LinearAlgebra


template <>
struct is_serial_vector<LinearAlgebra::EpetraWrappers::Vector> : std::false_type
{};

DEAL_II_NAMESPACE_CLOSE

#endif

#endif