trilinos_tpetra_block_vector.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 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_trilinos_tpetra_block_vector_h
#define dealii_trilinos_tpetra_block_vector_h
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_TRILINOS_WITH_TPETRA
 
#  include <deal.II/lac/block_indices.h>
#  include <deal.II/lac/block_vector_base.h>
#  include <deal.II/lac/trilinos_tpetra_block_sparse_matrix.h>
#  include <deal.II/lac/trilinos_tpetra_vector.h>
 
DEAL_II_NAMESPACE_OPEN
 
// forward declaration
#  ifndef DOXYGEN
template <typename Number>
class BlockVectorBase;
 
namespace LinearAlgebra
{
  // forward declaration
  namespace TpetraWrappers
  {
    template <typename Number, typename MemorySpace>
    class BlockVector;
 
    template <typename Number, typename MemorySpace>
    class BlockSparseMatrix;
  } // namespace TpetraWrappers
} // namespace LinearAlgebra
#  endif // DOXYGEN
 
namespace LinearAlgebra
{
  namespace TpetraWrappers
  {
    template <typename Number, typename MemorySpace = ::MemorySpace::Host>
    class BlockVector : public ::BlockVectorBase<
                          TpetraWrappers::Vector<Number, MemorySpace>>
    {
    public:
      using BaseClass =
        ::BlockVectorBase<TpetraWrappers::Vector<Number, MemorySpace>>;
 
      using BlockType = typename BaseClass::BlockType;
 
      using value_type      = typename BaseClass::value_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;
 
      BlockVector() = default;
 
      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<Number, MemorySpace> &v);
 
      explicit BlockVector(const size_type num_blocks);
 
      ~BlockVector() override = default;
 
      BlockVector<Number, MemorySpace> &
      operator=(const Number s);
 
      BlockVector<Number, MemorySpace> &
      operator=(const BlockVector<Number, MemorySpace> &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<Number, MemorySpace> &V,
             const bool omit_zeroing_entries = false);
 
      void
      reinit(const size_type num_blocks);
 
      bool
      has_ghost_elements() const;
 
      void
      print(std::ostream      &out,
            const unsigned int precision  = 3,
            const bool         scientific = true,
            const bool         across     = true) const;
    };
  } // namespace TpetraWrappers
 
} // namespace LinearAlgebra
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // DEAL_II_TRILINOS_WITH_TPETRA
 
#endif // dealii_trilinos_tpetra_block_vector_h