trilinos_epetra_vector.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2015 - 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_epetra_vector_h
#define dealii_trilinos_epetra_vector_h
 
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_TRILINOS
 
#  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_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 <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_elements(
        const ReadWriteVector<double> &V,
        VectorOperation::values        operation,
        std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
          communication_pattern = {}) override;
 
      DEAL_II_DEPRECATED_EARLY
      virtual void
      import(const ReadWriteVector<double> &V,
             VectorOperation::values        operation,
             std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
               communication_pattern = {}) override
      {
        import_elements(V, operation, communication_pattern);
      }
 
      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;
 
      size_type
      locally_owned_size() const;
 
      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