petsc_block_vector.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2004 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_petsc_block_vector_h
#define dealii_petsc_block_vector_h
 
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_PETSC
 
#  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/petsc_vector.h>
#  include <deal.II/lac/vector_type_traits.h>
 
DEAL_II_NAMESPACE_OPEN
 
 
namespace PETScWrappers
{
  // forward declaration
  class BlockVector;
 
  namespace MPI
  {
    class BlockVector : public BlockVectorBase<Vector>
    {
    public:
      using BaseClass = BlockVectorBase<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();
 
      explicit BlockVector(const unsigned int n_blocks,
                           const MPI_Comm     communicator,
                           const size_type    block_size,
                           const size_type    locally_owned_size);
 
      BlockVector(const BlockVector &V);
 
      BlockVector(const std::vector<size_type> &block_sizes,
                  const MPI_Comm                communicator,
                  const std::vector<size_type> &local_elements);
 
      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_indices,
                  const MPI_Comm               communicator);
 
      explicit BlockVector(Vec v);
 
      template <size_t num_blocks>
      explicit BlockVector(const std::array<Vec, num_blocks> &);
 
      ~BlockVector() override;
 
      BlockVector &
      operator=(const value_type s);
 
      BlockVector &
      operator=(const BlockVector &V);
 
      void
      reinit(Vec v);
 
      void
      reinit(const unsigned int n_blocks,
             const MPI_Comm     communicator,
             const size_type    block_size,
             const size_type    locally_owned_size,
             const bool         omit_zeroing_entries = false);
 
      void
      reinit(const std::vector<size_type> &block_sizes,
             const MPI_Comm                communicator,
             const std::vector<size_type> &locally_owned_sizes,
             const bool                    omit_zeroing_entries = false);
 
      void
      reinit(const BlockVector &V, const bool omit_zeroing_entries = false);
 
      void
      reinit(const std::vector<IndexSet> &parallel_partitioning,
             const MPI_Comm               communicator);
 
      void
      reinit(const std::vector<IndexSet> &parallel_partitioning,
             const std::vector<IndexSet> &ghost_entries,
             const MPI_Comm               communicator);
 
      void
      reinit(
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
                  &partitioners,
        const bool make_ghosted = true);
 
      void
      collect_sizes();
 
      void
      compress(VectorOperation::values operation);
 
      void
      reinit(const unsigned int num_blocks);
 
      bool
      has_ghost_elements() const;
 
      MPI_Comm
      get_mpi_communicator() const;
 
      operator const Vec &() const;
 
      Vec &
      petsc_vector();
 
      void
      swap(BlockVector &v) noexcept;
 
      void
      print(std::ostream      &out,
            const unsigned int precision  = 3,
            const bool         scientific = true,
            const bool         across     = true) const;
 
      DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);
      DeclException0(ExcNonMatchingBlockVectors);
 
    private:
      Vec petsc_nest_vector;
 
      void
      setup_nest_vec();
    };
 
    /*--------------------- Inline functions --------------------------------*/
 
    inline BlockVector::BlockVector()
      : BlockVectorBase<Vector>()
      , petsc_nest_vector(nullptr)
    {}
 
 
 
    inline BlockVector::BlockVector(const unsigned int n_blocks,
                                    const MPI_Comm     communicator,
                                    const size_type    block_size,
                                    const size_type    locally_owned_size)
      : BlockVector()
    {
      reinit(n_blocks, communicator, block_size, locally_owned_size);
    }
 
 
 
    inline BlockVector::BlockVector(
      const std::vector<size_type> &block_sizes,
      const MPI_Comm                communicator,
      const std::vector<size_type> &local_elements)
      : BlockVector()
    {
      reinit(block_sizes, communicator, local_elements, false);
    }
 
 
 
    inline BlockVector::BlockVector(const BlockVector &v)
      : BlockVector()
    {
      this->block_indices = v.block_indices;
 
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i] = v.components[i];
 
      this->collect_sizes();
    }
 
 
 
    inline BlockVector::BlockVector(
      const std::vector<IndexSet> &parallel_partitioning,
      const MPI_Comm               communicator)
      : BlockVector()
    {
      reinit(parallel_partitioning, communicator);
    }
 
 
 
    inline BlockVector::BlockVector(
      const std::vector<IndexSet> &parallel_partitioning,
      const std::vector<IndexSet> &ghost_indices,
      const MPI_Comm               communicator)
      : BlockVector()
    {
      reinit(parallel_partitioning, ghost_indices, communicator);
    }
 
 
 
    inline BlockVector::BlockVector(Vec v)
      : BlockVector()
    {
      this->reinit(v);
    }
 
 
 
    template <size_t num_blocks>
    inline BlockVector::BlockVector(const std::array<Vec, num_blocks> &arrayV)
      : BlockVector()
    {
      this->block_indices.reinit(num_blocks, 0);
 
      this->components.resize(num_blocks);
      for (auto i = 0; i < num_blocks; ++i)
        this->components[i].reinit(arrayV[i]);
      this->collect_sizes();
    }
 
 
 
    inline BlockVector &
    BlockVector::operator=(const value_type s)
    {
      BaseClass::operator=(s);
      return *this;
    }
 
 
 
    inline BlockVector &
    BlockVector::operator=(const BlockVector &v)
    {
      // we only allow assignment to vectors with the same number of blocks
      // or to an empty BlockVector
      Assert(this->n_blocks() == 0 || this->n_blocks() == v.n_blocks(),
             ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
 
      if (this->n_blocks() != v.n_blocks())
        this->block_indices = v.block_indices;
 
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i] = v.components[i];
 
      this->collect_sizes();
 
      return *this;
    }
 
 
 
    inline void
    BlockVector::reinit(const unsigned int n_blocks,
                        const MPI_Comm     communicator,
                        const size_type    block_size,
                        const size_type    locally_owned_size,
                        const bool         omit_zeroing_entries)
    {
      reinit(std::vector<size_type>(n_blocks, block_size),
             communicator,
             std::vector<size_type>(n_blocks, locally_owned_size),
             omit_zeroing_entries);
    }
 
 
 
    inline void
    BlockVector::reinit(const std::vector<size_type> &block_sizes,
                        const MPI_Comm                communicator,
                        const std::vector<size_type> &locally_owned_sizes,
                        const bool                    omit_zeroing_entries)
    {
      this->block_indices.reinit(block_sizes);
 
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i].reinit(communicator,
                                   block_sizes[i],
                                   locally_owned_sizes[i],
                                   omit_zeroing_entries);
 
      this->collect_sizes();
    }
 
 
    inline void
    BlockVector::reinit(const BlockVector &v, const bool omit_zeroing_entries)
    {
      if (this->n_blocks() != v.n_blocks())
        this->block_indices = v.get_block_indices();
 
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i].reinit(v.components[i], omit_zeroing_entries);
 
      this->collect_sizes();
    }
 
 
 
    inline void
    BlockVector::reinit(const std::vector<IndexSet> &parallel_partitioning,
                        const MPI_Comm               communicator)
    {
      // update the number of blocks
      this->block_indices.reinit(parallel_partitioning.size(), 0);
 
      // initialize each block
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i].reinit(parallel_partitioning[i], communicator);
 
      // update block_indices content
      this->collect_sizes();
    }
 
 
 
    inline void
    BlockVector::reinit(const std::vector<IndexSet> &parallel_partitioning,
                        const std::vector<IndexSet> &ghost_entries,
                        const MPI_Comm               communicator)
    {
      AssertDimension(parallel_partitioning.size(), ghost_entries.size());
 
      // update the number of blocks
      this->block_indices.reinit(parallel_partitioning.size(), 0);
 
      // initialize each block
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i].reinit(parallel_partitioning[i],
                                   ghost_entries[i],
                                   communicator);
 
      // update block_indices content
      this->collect_sizes();
    }
 
 
 
    inline void
    BlockVector::reinit(
      const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
                &partitioners,
      const bool make_ghosted)
    {
      // update the number of blocks
      this->block_indices.reinit(partitioners.size(), 0);
 
      // initialize each block
      this->components.resize(this->n_blocks());
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        this->components[i].reinit(partitioners[i], make_ghosted);
 
      // update block_indices content
      this->collect_sizes();
    }
 
 
 
    inline MPI_Comm
    BlockVector::get_mpi_communicator() const
    {
      return PetscObjectComm(reinterpret_cast<PetscObject>(petsc_nest_vector));
    }
 
 
 
    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) noexcept
    {
      std::swap(this->components, v.components);
      std::swap(this->petsc_nest_vector, v.petsc_nest_vector);
 
      ::swap(this->block_indices, v.block_indices);
    }
 
 
 
    inline void
    BlockVector::print(std::ostream      &out,
                       const unsigned int precision,
                       const bool         scientific,
                       const bool         across) const
    {
      for (unsigned int i = 0; i < this->n_blocks(); ++i)
        {
          if (across)
            out << 'C' << i << ':';
          else
            out << "Component " << i << std::endl;
          this->components[i].print(out, precision, scientific, across);
        }
    }
 
 
 
    inline void
    swap(BlockVector &u, BlockVector &v) noexcept
    {
      u.swap(v);
    }
  } // namespace MPI
 
} // namespace PETScWrappers
 
namespace internal
{
  namespace LinearOperatorImplementation
  {
    template <typename>
    class ReinitHelper;
 
    template <>
    class ReinitHelper<PETScWrappers::MPI::BlockVector>
    {
    public:
      template <typename Matrix>
      static void
      reinit_range_vector(const Matrix                    &matrix,
                          PETScWrappers::MPI::BlockVector &v,
                          bool /*omit_zeroing_entries*/)
      {
        v.reinit(matrix.locally_owned_range_indices(),
                 matrix.get_mpi_communicator());
      }
 
      template <typename Matrix>
      static void
      reinit_domain_vector(const Matrix                    &matrix,
                           PETScWrappers::MPI::BlockVector &v,
                           bool /*omit_zeroing_entries*/)
      {
        v.reinit(matrix.locally_owned_domain_indices(),
                 matrix.get_mpi_communicator());
      }
    };
 
  } // namespace LinearOperatorImplementation
} /* namespace internal */
 
 
template <>
struct is_serial_vector<PETScWrappers::MPI::BlockVector> : std::false_type
{};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // DEAL_II_WITH_PETSC
 
#endif