petsc_block_sparse_matrix.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2004 - 2023 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_sparse_matrix_h
#define dealii_petsc_block_sparse_matrix_h
 
 
#include <deal.II/base/config.h>
 
#ifdef DEAL_II_WITH_PETSC
 
#  include <deal.II/lac/block_matrix_base.h>
#  include <deal.II/lac/block_sparsity_pattern.h>
#  include <deal.II/lac/exceptions.h>
#  include <deal.II/lac/petsc_block_vector.h>
#  include <deal.II/lac/petsc_sparse_matrix.h>
 
#  include <cmath>
 
DEAL_II_NAMESPACE_OPEN
 
 
 
namespace PETScWrappers
{
  namespace MPI
  {
    class BlockSparseMatrix : public BlockMatrixBase<SparseMatrix>
    {
    public:
      using BaseClass = BlockMatrixBase<SparseMatrix>;
 
      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;
 
      BlockSparseMatrix();
 
      explicit BlockSparseMatrix(const Mat &);
 
      template <size_t block_rows, size_t block_columns>
      explicit BlockSparseMatrix(
        const std::array<std::array<Mat, block_columns>, block_rows> &);
 
      ~BlockSparseMatrix() override;
 
      BlockSparseMatrix &
      operator=(const BlockSparseMatrix &);
 
      BlockSparseMatrix &
      operator=(const double d);
 
      void
      reinit(const size_type n_block_rows, const size_type n_block_columns);
 
 
      void
      reinit(const std::vector<IndexSet>       &rows,
             const std::vector<IndexSet>       &cols,
             const BlockDynamicSparsityPattern &bdsp,
             const MPI_Comm                     com);
 
 
      void
      reinit(const std::vector<IndexSet>       &sizes,
             const BlockDynamicSparsityPattern &bdsp,
             const MPI_Comm                     com);
 
 
      void
      reinit(Mat A);
 
 
      void
      vmult(BlockVector &dst, const BlockVector &src) const;
 
      void
      vmult(BlockVector &dst, const Vector &src) const;
 
      void
      vmult(Vector &dst, const BlockVector &src) const;
 
      void
      vmult(Vector &dst, const Vector &src) const;
 
      void
      Tvmult(BlockVector &dst, const BlockVector &src) const;
 
      void
      Tvmult(BlockVector &dst, const Vector &src) const;
 
      void
      Tvmult(Vector &dst, const BlockVector &src) const;
 
      void
      Tvmult(Vector &dst, const Vector &src) const;
 
      void
      collect_sizes();
 
      void
      compress(VectorOperation::values operation);
 
      std::vector<IndexSet>
      locally_owned_domain_indices() const;
 
      std::vector<IndexSet>
      locally_owned_range_indices() const;
 
      std::uint64_t
      n_nonzero_elements() const;
 
      MPI_Comm
      get_mpi_communicator() const;
 
      using BlockMatrixBase<SparseMatrix>::clear;
 
      operator const Mat &() const;
 
      Mat &
      petsc_matrix();
 
    private:
      Mat petsc_nest_matrix;
 
      void
      setup_nest_mat();
 
      void
      create_empty_matrices_if_needed();
    };
 
 
 
    // ------------- inline and template functions -----------------
    inline BlockSparseMatrix::BlockSparseMatrix()
      : BaseClass()
      , petsc_nest_matrix(nullptr)
    {}
 
 
 
    inline BlockSparseMatrix::BlockSparseMatrix(const Mat &A)
      : BlockSparseMatrix()
    {
      this->reinit(A);
    }
 
 
 
    template <size_t block_rows, size_t block_columns>
    inline BlockSparseMatrix::BlockSparseMatrix(
      const std::array<std::array<Mat, block_columns>, block_rows> &arrayA)
      : BlockSparseMatrix()
    {
      this->reinit(block_rows, block_columns);
      this->sub_objects.reinit(block_rows, block_columns);
      for (auto r = 0; r < block_rows; ++r)
        for (auto c = 0; c < block_columns; ++c)
          {
            if (arrayA[r][c])
              this->sub_objects[r][c] = new BlockType(arrayA[r][c]);
            else
              this->sub_objects[r][c] = nullptr;
          }
      this->collect_sizes();
    }
 
 
 
    inline BlockSparseMatrix &
    BlockSparseMatrix::operator=(const double d)
    {
      Assert(d == 0, ExcScalarAssignmentOnlyForZeroValue());
 
      for (size_type r = 0; r < this->n_block_rows(); ++r)
        for (size_type c = 0; c < this->n_block_cols(); ++c)
          this->block(r, c) = d;
 
      return *this;
    }
 
 
 
    inline void
    BlockSparseMatrix::vmult(BlockVector &dst, const BlockVector &src) const
    {
      BaseClass::vmult_block_block(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::vmult(BlockVector &dst, const Vector &src) const
    {
      BaseClass::vmult_block_nonblock(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::vmult(Vector &dst, const BlockVector &src) const
    {
      BaseClass::vmult_nonblock_block(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::vmult(Vector &dst, const Vector &src) const
    {
      BaseClass::vmult_nonblock_nonblock(dst, src);
    }
 
 
    inline void
    BlockSparseMatrix::Tvmult(BlockVector &dst, const BlockVector &src) const
    {
      BaseClass::Tvmult_block_block(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::Tvmult(BlockVector &dst, const Vector &src) const
    {
      BaseClass::Tvmult_block_nonblock(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::Tvmult(Vector &dst, const BlockVector &src) const
    {
      BaseClass::Tvmult_nonblock_block(dst, src);
    }
 
 
 
    inline void
    BlockSparseMatrix::Tvmult(Vector &dst, const Vector &src) const
    {
      BaseClass::Tvmult_nonblock_nonblock(dst, src);
    }
 
  } // namespace MPI
 
} // namespace PETScWrappers
 
 
DEAL_II_NAMESPACE_CLOSE
 
 
#endif // DEAL_II_WITH_PETSC
 
#endif // dealii_petsc_block_sparse_matrix_h