petsc_block_sparse_matrix.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2004 - 2016 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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/base/table.h>
#  include <deal.II/lac/block_matrix_base.h>
#  include <deal.II/lac/petsc_sparse_matrix.h>
#  include <deal.II/lac/petsc_block_vector.h>
#  include <deal.II/lac/exceptions.h>

#  include <cmath>

DEAL_II_NAMESPACE_OPEN



namespace PETScWrappers
{

  class BlockSparseMatrix : public BlockMatrixBase<PETScWrappers::SparseMatrix>
  {
  public:
    typedef BlockMatrixBase<SparseMatrix> BaseClass;

    typedef BaseClass::BlockType  BlockType;

    typedef BaseClass::value_type      value_type;
    typedef BaseClass::pointer         pointer;
    typedef BaseClass::const_pointer   const_pointer;
    typedef BaseClass::reference       reference;
    typedef BaseClass::const_reference const_reference;
    typedef BaseClass::size_type       size_type;
    typedef BaseClass::iterator        iterator;
    typedef BaseClass::const_iterator  const_iterator;

    BlockSparseMatrix ();

    ~BlockSparseMatrix ();

    BlockSparseMatrix &
    operator = (const BlockSparseMatrix &);

    BlockSparseMatrix &
    operator = (const double d);

    void reinit (const size_type n_block_rows,
                 const size_type n_block_columns);

    void collect_sizes ();

    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;

    std::vector< size_type > locally_owned_domain_sizes() const;

    std::vector< size_type > locally_owned_range_sizes() const;

    using BlockMatrixBase<SparseMatrix>::clear;

    DeclException4 (ExcIncompatibleRowNumbers,
                    int, int, int, int,
                    << "The blocks [" << arg1 << ',' << arg2 << "] and ["
                    << arg3 << ',' << arg4 << "] have differing row numbers.");
    DeclException4 (ExcIncompatibleColNumbers,
                    int, int, int, int,
                    << "The blocks [" << arg1 << ',' << arg2 << "] and ["
                    << arg3 << ',' << arg4 << "] have differing column numbers.");
  };



// ------------- 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);
  }

}

DEAL_II_NAMESPACE_CLOSE

#endif    // DEAL_II_WITH_PETSC

#endif    // dealii__petsc_block_sparse_matrix_h