trilinos_epetra_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2015 - 2018 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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 <memory>

#  include <mpi.h>
#  include <Epetra_FEVector.h>

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;
    }
  }
}


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

DEAL_II_NAMESPACE_CLOSE

#endif

#endif