trilinos_parallel_block_vector.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2008 - 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_trilinos_parallel_block_vector_h
#define dealii_trilinos_parallel_block_vector_h


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

#ifdef DEAL_II_WITH_TRILINOS

#  include <deal.II/lac/block_indices.h>
#  include <deal.II/lac/block_vector_base.h>
#  include <deal.II/lac/exceptions.h>
#  include <deal.II/lac/trilinos_vector.h>

#  include <functional>

DEAL_II_NAMESPACE_OPEN

// forward declaration
template <typename Number>
class BlockVectorBase;

namespace TrilinosWrappers
{
  // forward declaration
  namespace MPI
  {
    class BlockVector;
  }
  class BlockSparseMatrix;


  namespace MPI
  {
    class BlockVector : public ::BlockVectorBase<MPI::Vector>
    {
    public:
      using BaseClass = ::BlockVectorBase<MPI::Vector>;

      using BlockType = BaseClass::BlockType;

      using value_type      = BaseClass::value_type;
      using pointer         = BaseClass::pointer;
      using const_pointer   = BaseClass::const_pointer;
      using reference       = BaseClass::reference;
      using const_reference = BaseClass::const_reference;
      using size_type       = BaseClass::size_type;
      using iterator        = BaseClass::iterator;
      using const_iterator  = BaseClass::const_iterator;

      BlockVector() = default;

      explicit BlockVector(const std::vector<IndexSet> &parallel_partitioning,
                           const MPI_Comm &communicator = MPI_COMM_WORLD);

      BlockVector(const std::vector<IndexSet> &parallel_partitioning,
                  const std::vector<IndexSet> &ghost_values,
                  const MPI_Comm &             communicator,
                  const bool                   vector_writable = false);

      BlockVector(const BlockVector &v);

      BlockVector(BlockVector &&v) noexcept;

      explicit BlockVector(const size_type num_blocks);

      ~BlockVector() override = default;

      BlockVector &
      operator=(const value_type s);

      BlockVector &
      operator=(const BlockVector &v);

      BlockVector &
      operator=(BlockVector &&v) noexcept;

      template <typename Number>
      BlockVector &
      operator=(const ::BlockVector<Number> &v);

      void
      reinit(const std::vector<IndexSet> &parallel_partitioning,
             const MPI_Comm &             communicator         = MPI_COMM_WORLD,
             const bool                   omit_zeroing_entries = false);

      void
      reinit(const std::vector<IndexSet> &partitioning,
             const std::vector<IndexSet> &ghost_values,
             const MPI_Comm &             communicator    = MPI_COMM_WORLD,
             const bool                   vector_writable = false);


      void
      reinit(const BlockVector &V, const bool omit_zeroing_entries = false);

      void
      reinit(const size_type num_blocks);

      void
      import_nonlocal_data_for_fe(const TrilinosWrappers::BlockSparseMatrix &m,
                                  const BlockVector &                        v);

      bool
      has_ghost_elements() const;

      void
      swap(BlockVector &v);

      void
      print(std::ostream &     out,
            const unsigned int precision  = 3,
            const bool         scientific = true,
            const bool         across     = true) const;

      DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);

      DeclException0(ExcNonMatchingBlockVectors);
    };



    /*-------------------------- Inline functions ---------------------------*/
    inline BlockVector::BlockVector(
      const std::vector<IndexSet> &parallel_partitioning,
      const MPI_Comm &             communicator)
    {
      reinit(parallel_partitioning, communicator, false);
    }



    inline BlockVector::BlockVector(
      const std::vector<IndexSet> &parallel_partitioning,
      const std::vector<IndexSet> &ghost_values,
      const MPI_Comm &             communicator,
      const bool                   vector_writable)
    {
      reinit(parallel_partitioning,
             ghost_values,
             communicator,
             vector_writable);
    }



    inline BlockVector::BlockVector(const size_type num_blocks)
    {
      reinit(num_blocks);
    }



    inline BlockVector::BlockVector(const BlockVector &v)
      : ::BlockVectorBase<MPI::Vector>()
    {
      this->components.resize(v.n_blocks());
      this->block_indices = v.block_indices;

      for (size_type i = 0; i < this->n_blocks(); ++i)
        this->components[i] = v.components[i];
    }



    inline BlockVector::BlockVector(BlockVector &&v) noexcept
    {
      // initialize a minimal, valid object and swap
      reinit(0);
      swap(v);
    }



    template <typename Number>
    BlockVector &
    BlockVector::operator=(const ::BlockVector<Number> &v)
    {
      if (n_blocks() != v.n_blocks())
        {
          std::vector<size_type> block_sizes(v.n_blocks(), 0);
          block_indices.reinit(block_sizes);
          if (components.size() != n_blocks())
            components.resize(n_blocks());
        }

      for (size_type i = 0; i < this->n_blocks(); ++i)
        this->components[i] = v.block(i);

      collect_sizes();

      return *this;
    }



    inline bool
    BlockVector::has_ghost_elements() const
    {
      bool ghosted = block(0).has_ghost_elements();
#  ifdef DEBUG
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        Assert(block(i).has_ghost_elements() == ghosted, ExcInternalError());
#  endif
      return ghosted;
    }



    inline void
    BlockVector::swap(BlockVector &v)
    {
      std::swap(this->components, v.components);

      ::swap(this->block_indices, v.block_indices);
    }



    inline void
    swap(BlockVector &u, BlockVector &v)
    {
      u.swap(v);
    }

  } /* namespace MPI */

} /* namespace TrilinosWrappers */

namespace internal
{
  namespace LinearOperatorImplementation
  {
    template <typename>
    class ReinitHelper;

    template <>
    class ReinitHelper<TrilinosWrappers::MPI::BlockVector>
    {
    public:
      template <typename Matrix>
      static void
      reinit_range_vector(const Matrix &                      matrix,
                          TrilinosWrappers::MPI::BlockVector &v,
                          bool omit_zeroing_entries)
      {
        v.reinit(matrix.locally_owned_range_indices(),
                 matrix.get_mpi_communicator(),
                 omit_zeroing_entries);
      }

      template <typename Matrix>
      static void
      reinit_domain_vector(const Matrix &                      matrix,
                           TrilinosWrappers::MPI::BlockVector &v,
                           bool omit_zeroing_entries)
      {
        v.reinit(matrix.locally_owned_domain_indices(),
                 matrix.get_mpi_communicator(),
                 omit_zeroing_entries);
      }
    };

  } // namespace LinearOperatorImplementation
} /* namespace internal */


template <>
struct is_serial_vector<TrilinosWrappers::MPI::BlockVector> : std::false_type
{};

DEAL_II_NAMESPACE_CLOSE

#endif // DEAL_II_WITH_TRILINOS

#endif