la_parallel_block_vector.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 2016 - 2026 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_la_parallel_block_vector_h
#define dealii_la_parallel_block_vector_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
 
#include <deal.II/lac/block_indices.h>
#include <deal.II/lac/block_vector_base.h>
#include <deal.II/lac/la_parallel_vector.h>
#include <deal.II/lac/trilinos_tpetra_to_trilinos_wrappers.h>
#include <deal.II/lac/vector_operation.h>
#include <deal.II/lac/vector_type_traits.h>
 
#include <cstdio>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
// Forward declarations
#ifndef DOXYGEN
#  ifdef DEAL_II_WITH_PETSC
namespace PETScWrappers
{
  namespace MPI
  {
    class BlockVector;
  }
} // namespace PETScWrappers
#  endif
#endif
 
namespace LinearAlgebra
{
  namespace distributed
  {
    template <typename Number, typename MemorySpace = MemorySpace::Host>
    class BlockVector : public BlockVectorBase<Vector<Number, MemorySpace>>
    {
    public:
      static constexpr unsigned int communication_block_size = 20;
 
      using BaseClass = BlockVectorBase<Vector<Number, MemorySpace>>;
 
      using BlockType = typename BaseClass::BlockType;
 
      using value_type      = typename BaseClass::value_type;
      using real_type       = typename BaseClass::real_type;
      using pointer         = typename BaseClass::pointer;
      using const_pointer   = typename BaseClass::const_pointer;
      using reference       = typename BaseClass::reference;
      using const_reference = typename BaseClass::const_reference;
      using size_type       = typename BaseClass::size_type;
      using iterator        = typename BaseClass::iterator;
      using const_iterator  = typename BaseClass::const_iterator;
 
      explicit BlockVector(const size_type num_blocks = 0,
                           const size_type block_size = 0);
 
      BlockVector(const BlockVector<Number, MemorySpace> &V);
 
      template <typename OtherNumber>
      explicit BlockVector(const BlockVector<OtherNumber, MemorySpace> &v);
 
      BlockVector(const std::vector<size_type> &block_sizes);
 
      BlockVector(const std::vector<IndexSet> &local_ranges,
                  const std::vector<IndexSet> &ghost_indices,
                  const MPI_Comm               communicator);
 
      BlockVector(const std::vector<IndexSet> &local_ranges,
                  const MPI_Comm               communicator);
 
      BlockVector(
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
                       &partitioners,
        const MPI_Comm &comm_sm = MPI_COMM_SELF);
 
      ~BlockVector() = default;
 
      BlockVector &
      operator=(const value_type s);
 
      BlockVector &
      operator=(const BlockVector &V);
 
      template <class Number2>
      BlockVector &
      operator=(const BlockVector<Number2, MemorySpace> &V);
 
      BlockVector &
      operator=(const Vector<Number, MemorySpace> &V);
 
#ifdef DEAL_II_WITH_PETSC
      BlockVector<Number, MemorySpace> &
      operator=(const PETScWrappers::MPI::BlockVector &petsc_vec);
#endif
 
#ifdef DEAL_II_TRILINOS_WITH_EPETRA
      BlockVector<Number, MemorySpace> &
      operator=(const TrilinosWrappers::MPI::BlockVector &trilinos_vec);
#endif
 
      void
      reinit(const size_type num_blocks,
             const size_type block_size           = 0,
             const bool      omit_zeroing_entries = false);
 
      void
      reinit(const std::vector<size_type> &block_sizes,
             const bool                    omit_zeroing_entries = false);
 
      template <typename Number2>
      void
      reinit(const BlockVector<Number2, MemorySpace> &V,
             const bool omit_zeroing_entries = false);
 
      void
      reinit(const std::vector<IndexSet> &local_ranges,
             const std::vector<IndexSet> &ghost_indices,
             const MPI_Comm               communicator);
 
      void
      reinit(const std::vector<IndexSet> &local_ranges,
             const MPI_Comm               communicator);
 
      void
      reinit(
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
                       &partitioners,
        const MPI_Comm &comm_sm = MPI_COMM_SELF);
 
      void
      reinit(
        const std::vector<std::shared_ptr<const Utilities::MPI::Partitioner>>
                       &partitioners,
        const bool      make_ghosted,
        const MPI_Comm &comm_sm = MPI_COMM_SELF);
 
      void
      compress(VectorOperation::values operation);
 
      void
      update_ghost_values() const;
 
      void
      update_ghost_values_start(
        const unsigned int communication_channel_start = 100) const;
 
      void
      update_ghost_values_finish() const;
 
      void
      zero_out_ghost_values() const;
 
      bool
      has_ghost_elements() const;
 
      void
      set_ghost_state(const bool ghosted) const;
 
      template <typename Number2>
      void
      copy_locally_owned_data_from(
        const BlockVector<Number2, MemorySpace> &src);
 
      template <typename OtherNumber>
      void
      add(const std::vector<size_type>        &indices,
          const ::Vector<OtherNumber> &values);
 
      void
      sadd(const Number s, const BlockVector<Number, MemorySpace> &V);
 
      bool
      all_zero() const;
 
      Number
      mean_value() const;
 
      real_type
      lp_norm(const real_type p) const;
 
      void
      swap(BlockVector<Number, MemorySpace> &v) noexcept;
      BlockVector<Number, MemorySpace> &
      operator*=(const Number factor);
 
      BlockVector<Number, MemorySpace> &
      operator/=(const Number factor);
 
      BlockVector<Number, MemorySpace> &
      operator+=(const BlockVector<Number, MemorySpace> &V);
 
      BlockVector<Number, MemorySpace> &
      operator-=(const BlockVector<Number, MemorySpace> &V);
 
      void
      import_elements(
        const LinearAlgebra::ReadWriteVector<Number> &V,
        const VectorOperation::values                 operation,
        const std::shared_ptr<const Utilities::MPI::CommunicationPatternBase>
          &communication_pattern = {});
 
      Number
      operator*(const BlockVector<Number, MemorySpace> &V) const;
 
      template <typename FullMatrixType>
      void
      multivector_inner_product(FullMatrixType                         &matrix,
                                const BlockVector<Number, MemorySpace> &V,
                                const bool symmetric = false) const;
 
      template <typename FullMatrixType>
      Number
      multivector_inner_product_with_metric(
        const FullMatrixType                   &matrix,
        const BlockVector<Number, MemorySpace> &V,
        const bool                              symmetric = false) const;
 
      template <typename FullMatrixType>
      void
      mmult(BlockVector<Number, MemorySpace> &V,
            const FullMatrixType             &matrix,
            const Number                      s = Number(0.),
            const Number                      b = Number(1.)) const;
 
      void
      add(const Number a);
 
      void
      add(const Number a, const BlockVector<Number, MemorySpace> &V);
 
      void
      add(const Number                            a,
          const BlockVector<Number, MemorySpace> &V,
          const Number                            b,
          const BlockVector<Number, MemorySpace> &W);
 
      void
      add(const std::vector<size_type> &indices,
          const std::vector<Number>    &values);
 
      void
      sadd(const Number                            s,
           const Number                            a,
           const BlockVector<Number, MemorySpace> &V);
 
      void
      scale(const BlockVector<Number, MemorySpace> &scaling_factors);
 
      void
      equ(const Number a, const BlockVector<Number, MemorySpace> &V);
 
      real_type
      l1_norm() const;
 
      real_type
      l2_norm() const;
 
      real_type
      norm_sqr() const;
 
      real_type
      linfty_norm() const;
 
      Number
      add_and_dot(const Number                            a,
                  const BlockVector<Number, MemorySpace> &V,
                  const BlockVector<Number, MemorySpace> &W);
 
      virtual size_type
      size() const override;
 
      ::IndexSet
      locally_owned_elements() const;
 
      void
      print(std::ostream      &out,
            const unsigned int precision  = 3,
            const bool         scientific = true,
            const bool         across     = true) const;
 
      std::size_t
      memory_consumption() const;
      DeclException0(ExcVectorTypeNotCompatible);
 
      DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);
    };
 
  } // end of namespace distributed
 
} // end of namespace LinearAlgebra
 
 
template <typename Number, typename MemorySpace>
inline void
swap(LinearAlgebra::distributed::BlockVector<Number, MemorySpace> &u,
     LinearAlgebra::distributed::BlockVector<Number, MemorySpace> &v) noexcept
{
  u.swap(v);
}
 
 
template <typename Number, typename MemorySpace>
struct is_serial_vector<
  LinearAlgebra::distributed::BlockVector<Number, MemorySpace>>
  : std::false_type
{};
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif