petsc_block_sparse_matrix.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2004 - 2020 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_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() = default;
 
      ~BlockSparseMatrix() override = default;
 
      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
      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();
 
      std::vector<IndexSet>
      locally_owned_domain_indices() const;
 
      std::vector<IndexSet>
      locally_owned_range_indices() const;
 
      const MPI_Comm &
      get_mpi_communicator() const;
 
      using BlockMatrixBase<SparseMatrix>::clear;
    };
 
 
 
    // ------------- inline and template functions -----------------
 
    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