block_sparse_matrix_ez.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) 2002 - 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_block_sparse_matrix_ez_h
#define dealii_block_sparse_matrix_ez_h
 
 
// TODO: Derive BlockSparseMatrixEZ from BlockMatrixBase, like all the
// other block matrices as well; this would allow to instantiate a few
// functions with this template argument as well (in particular
// AffineConstraints::distribute_local_to_global)
 
#include <deal.II/base/config.h>
 
#include <deal.II/lac/block_indices.h>
#include <deal.II/lac/block_matrix_base.h>
#include <deal.II/lac/sparse_matrix_ez.h>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declaration
#ifndef DOXYGEN
template <typename Number>
class BlockVector;
#endif
 
template <typename Number>
class BlockSparseMatrixEZ : public BlockMatrixBase<SparseMatrixEZ<Number>>
{
public:
  using BaseClass = BlockMatrixBase<SparseMatrixEZ<Number>>;
 
  using size_type = types::global_dof_index;
 
  BlockSparseMatrixEZ() = default;
 
  BlockSparseMatrixEZ(const unsigned int block_rows,
                      const unsigned int block_cols);
 
  BlockSparseMatrixEZ(const BlockSparseMatrixEZ<Number> &);
 
  BlockSparseMatrixEZ &
  operator=(const BlockSparseMatrixEZ<Number> &);
 
  BlockSparseMatrixEZ &
  operator=(const double d);
 
  void
  clear();
 
  void
  reinit(const unsigned int n_block_rows, const unsigned int n_block_cols);
 
  void
  collect_sizes();
 
  bool
  empty() const;
 
  template <typename block_number>
  void
  vmult(BlockVector<block_number>       &dst,
        const BlockVector<block_number> &src) const;
 
  template <typename block_number, typename nonblock_number>
  void
  vmult(BlockVector<block_number>     &dst,
        const Vector<nonblock_number> &src) const;
 
  template <typename block_number, typename nonblock_number>
  void
  vmult(Vector<nonblock_number>         &dst,
        const BlockVector<block_number> &src) const;
 
  template <typename nonblock_number>
  void
  vmult(Vector<nonblock_number> &dst, const Vector<nonblock_number> &src) const;
 
  template <typename block_number>
  void
  Tvmult(BlockVector<block_number>       &dst,
         const BlockVector<block_number> &src) const;
 
  template <typename block_number, typename nonblock_number>
  void
  Tvmult(BlockVector<block_number>     &dst,
         const Vector<nonblock_number> &src) const;
 
  template <typename block_number, typename nonblock_number>
  void
  Tvmult(Vector<nonblock_number>         &dst,
         const BlockVector<block_number> &src) const;
 
  template <typename nonblock_number>
  void
  Tvmult(Vector<nonblock_number>       &dst,
         const Vector<nonblock_number> &src) const;
  template <typename StreamType>
  void
  print_statistics(StreamType &s, bool full = false);
};
 
/*----------------------------------------------------------------------*/
 
 
 
template <typename number>
template <typename block_number>
inline void
BlockSparseMatrixEZ<number>::vmult(BlockVector<block_number>       &dst,
                                   const BlockVector<block_number> &src) const
{
  BaseClass::vmult_block_block(dst, src);
}
 
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::vmult(BlockVector<block_number>     &dst,
                                   const Vector<nonblock_number> &src) const
{
  BaseClass::vmult_block_nonblock(dst, src);
}
 
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::vmult(Vector<nonblock_number>         &dst,
                                   const BlockVector<block_number> &src) const
{
  BaseClass::vmult_nonblock_block(dst, src);
}
 
template <typename number>
template <typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::vmult(Vector<nonblock_number>       &dst,
                                   const Vector<nonblock_number> &src) const
{
  BaseClass::vmult_nonblock_nonblock(dst, src);
}
 
template <typename number>
template <typename block_number>
inline void
BlockSparseMatrixEZ<number>::Tvmult(BlockVector<block_number>       &dst,
                                    const BlockVector<block_number> &src) const
{
  BaseClass::Tvmult_block_block(dst, src);
}
 
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::Tvmult(BlockVector<block_number>     &dst,
                                    const Vector<nonblock_number> &src) const
{
  BaseClass::Tvmult_block_nonblock(dst, src);
}
 
template <typename number>
template <typename block_number, typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::Tvmult(Vector<nonblock_number>         &dst,
                                    const BlockVector<block_number> &src) const
{
  BaseClass::Tvmult_nonblock_block(dst, src);
}
 
template <typename number>
template <typename nonblock_number>
inline void
BlockSparseMatrixEZ<number>::Tvmult(Vector<nonblock_number>       &dst,
                                    const Vector<nonblock_number> &src) const
{
  BaseClass::Tvmult_nonblock_nonblock(dst, src);
}
 
 
 
template <typename number>
template <typename StreamType>
inline void
BlockSparseMatrixEZ<number>::print_statistics(StreamType &out, bool full)
{
  size_type              used_total      = 0;
  size_type              allocated_total = 0;
  size_type              reserved_total  = 0;
  std::vector<size_type> used_by_line_total;
 
  size_type              used;
  size_type              allocated;
  size_type              reserved;
  std::vector<size_type> used_by_line;
 
  for (size_type i = 0; i < this->n_block_rows(); ++i)
    for (size_type j = 0; j < this->n_block_cols(); ++j)
      {
        used_by_line.clear();
        out << "block:\t" << i << '\t' << j << std::endl;
        this->sub_objects(i, j)->compute_statistics(
          used, allocated, reserved, used_by_line, full);
 
        out << "used:" << used << std::endl
            << "allocated:" << allocated << std::endl
            << "reserved:" << reserved << std::endl;
 
        used_total += used;
        allocated_total += allocated;
        reserved_total += reserved;
 
        if (full)
          {
            used_by_line_total.resize(used_by_line.size());
            for (size_type i = 0; i < used_by_line.size(); ++i)
              if (used_by_line[i] != 0)
                {
                  out << "row-entries\t" << i << "\trows\t" << used_by_line[i]
                      << std::endl;
                  used_by_line_total[i] += used_by_line[i];
                }
          }
      }
  out << "Total" << std::endl
      << "used:" << used_total << std::endl
      << "allocated:" << allocated_total << std::endl
      << "reserved:" << reserved_total << std::endl;
  for (size_type i = 0; i < used_by_line_total.size(); ++i)
    if (used_by_line_total[i] != 0)
      {
        out << "row-entries\t" << i << "\trows\t" << used_by_line_total[i]
            << std::endl;
      }
}
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_block_sparse_matrix_ez_h