BlockSparseMatrix< number > Class Template Reference
[Basic matrices]

Inheritance diagram for BlockSparseMatrix< number >:

Inheritance graph
[legend]

List of all members.

Classes

class  ExcBlockDimensionMismatch

Public Types

typedef BlockMatrixBase
< SparseMatrix< number > > 
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

Public Member Functions

 BlockSparseMatrix ()
 BlockSparseMatrix (const BlockSparsityPattern &sparsity)
virtual ~BlockSparseMatrix ()
BlockSparseMatrixoperator= (const BlockSparseMatrix &)
BlockSparseMatrix< number > & operator= (const double d)
void clear ()
virtual void reinit (const BlockSparsityPattern &sparsity)
bool empty () const
unsigned int n_nonzero_elements () const
unsigned int n_actually_nonzero_elements (const double threshold=0.0) 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<class BlockVectorType >
void precondition_Jacobi (BlockVectorType &dst, const BlockVectorType &src, const number omega=1.) const
template<typename number2 >
void precondition_Jacobi (Vector< number2 > &dst, const Vector< number2 > &src, const number omega=1.) const
void print_formatted (std::ostream &out, const unsigned int precision=3, const bool scientific=true, const unsigned int width=0, const char *zero_string=" ", const double denominator=1.) const
const BlockSparsityPatternget_sparsity_pattern () const
unsigned int memory_consumption () const

Private Attributes

SmartPointer< const
BlockSparsityPattern
sparsity_pattern


Detailed Description

template<typename number>
class BlockSparseMatrix< number >

Blocked sparse matrix based on the SparseMatrix class. This class implements the functions that are specific to the SparseMatrix base objects for a blocked sparse matrix, and leaves the actual work relaying most of the calls to the individual blocks to the functions implemented in the base class. See there also for a description of when this class is useful.

Author:
Wolfgang Bangerth, 2000, 2004

Member Typedef Documentation

template<typename number>
typedef BlockMatrixBase<SparseMatrix<number> > BlockSparseMatrix< number >::BaseClass

Typedef the base class for simpler access to its own typedefs.

template<typename number>
typedef BaseClass::BlockType BlockSparseMatrix< number >::BlockType

Typedef the type of the underlying matrix.

Reimplemented from BlockMatrixBase< SparseMatrix< number > >.

template<typename number>
typedef BaseClass::value_type BlockSparseMatrix< number >::value_type

Import the typedefs from the base class.

Reimplemented from BlockMatrixBase< SparseMatrix< number > >.

template<typename number>
typedef BaseClass::pointer BlockSparseMatrix< number >::pointer

template<typename number>
typedef BaseClass::const_pointer BlockSparseMatrix< number >::const_pointer

template<typename number>
typedef BaseClass::reference BlockSparseMatrix< number >::reference

template<typename number>
typedef BaseClass::const_reference BlockSparseMatrix< number >::const_reference

template<typename number>
typedef BaseClass::size_type BlockSparseMatrix< number >::size_type

template<typename number>
typedef BaseClass::iterator BlockSparseMatrix< number >::iterator

template<typename number>
typedef BaseClass::const_iterator BlockSparseMatrix< number >::const_iterator


Constructor & Destructor Documentation

template<typename number>
BlockSparseMatrix< number >::BlockSparseMatrix (  ) 

Constructor; initializes the matrix to be empty, without any structure, i.e. the matrix is not usable at all. This constructor is therefore only useful for matrices which are members of a class. All other matrices should be created at a point in the data flow where all necessary information is available.

You have to initialize the matrix before usage with reinit(BlockSparsityPattern). The number of blocks per row and column are then determined by that function.

template<typename number>
BlockSparseMatrix< number >::BlockSparseMatrix ( const BlockSparsityPattern sparsity  ) 

Constructor. Takes the given matrix sparsity structure to represent the sparsity pattern of this matrix. You can change the sparsity pattern later on by calling the reinit() function.

This constructor initializes all sub-matrices with the sub-sparsity pattern within the argument.

You have to make sure that the lifetime of the sparsity structure is at least as long as that of this matrix or as long as reinit() is not called with a new sparsity structure.

template<typename number>
virtual BlockSparseMatrix< number >::~BlockSparseMatrix (  )  [virtual]

Destructor.


Member Function Documentation

template<typename number>
BlockSparseMatrix& BlockSparseMatrix< number >::operator= ( const BlockSparseMatrix< number > &   ) 

Pseudo copy operator only copying empty objects. The sizes of the block matrices need to be the same.

template<typename number>
BlockSparseMatrix<number>& BlockSparseMatrix< number >::operator= ( const double  d  ) 

This operator assigns a scalar to a matrix. Since this does usually not make much sense (should we set all matrix entries to this value? Only the nonzero entries of the sparsity pattern?), this operation is only allowed if the actual value to be assigned is zero. This operator only exists to allow for the obvious notation matrix=0, which sets all elements of the matrix to zero, but keep the sparsity pattern previously used.

template<typename number>
void BlockSparseMatrix< number >::clear (  ) 

Release all memory and return to a state just like after having called the default constructor. It also forgets the sparsity pattern it was previously tied to.

This calls SparseMatrix::clear on all sub-matrices and then resets this object to have no blocks at all.

Reimplemented from BlockMatrixBase< SparseMatrix< number > >.

template<typename number>
virtual void BlockSparseMatrix< number >::reinit ( const BlockSparsityPattern sparsity  )  [virtual]

Reinitialize the sparse matrix with the given sparsity pattern. The latter tells the matrix how many nonzero elements there need to be reserved.

Basically, this function only calls SparseMatrix::reinit() of the sub-matrices with the block sparsity patterns of the parameter.

The elements of the matrix are set to zero by this function.

template<typename number>
bool BlockSparseMatrix< number >::empty (  )  const

Return whether the object is empty. It is empty if either both dimensions are zero or no BlockSparsityPattern is associated.

template<typename number>
unsigned int BlockSparseMatrix< number >::n_nonzero_elements (  )  const

Return the number of nonzero elements of this matrix. Actually, it returns the number of entries in the sparsity pattern; if any of the entries should happen to be zero, it is counted anyway.

template<typename number>
unsigned int BlockSparseMatrix< number >::n_actually_nonzero_elements ( const double  threshold = 0.0  )  const

Return the number of actually nonzero elements. Just counts the number of actually nonzero elements (with absolute value larger than threshold) of all the blocks.

template<typename number >
template<typename block_number >
void BlockSparseMatrix< number >::vmult ( BlockVector< block_number > &  dst,
const BlockVector< block_number > &  src 
) const [inline]

Matrix-vector multiplication: let $dst = M*src$ with $M$ being this matrix.

References BlockMatrixBase< SparseMatrix< number > >::vmult_block_block().

template<typename number >
template<typename block_number , typename nonblock_number >
void BlockSparseMatrix< number >::vmult ( BlockVector< block_number > &  dst,
const Vector< nonblock_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block column.

References BlockMatrixBase< SparseMatrix< number > >::vmult_block_nonblock().

template<typename number >
template<typename block_number , typename nonblock_number >
void BlockSparseMatrix< number >::vmult ( Vector< nonblock_number > &  dst,
const BlockVector< block_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block row.

References BlockMatrixBase< SparseMatrix< number > >::vmult_nonblock_block().

template<typename number >
template<typename nonblock_number >
void BlockSparseMatrix< number >::vmult ( Vector< nonblock_number > &  dst,
const Vector< nonblock_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block.

References BlockMatrixBase< SparseMatrix< number > >::vmult_nonblock_nonblock().

template<typename number >
template<typename block_number >
void BlockSparseMatrix< number >::Tvmult ( BlockVector< block_number > &  dst,
const BlockVector< block_number > &  src 
) const [inline]

Matrix-vector multiplication: let $dst = M^T*src$ with $M$ being this matrix. This function does the same as vmult() but takes the transposed matrix.

References BlockMatrixBase< SparseMatrix< number > >::Tvmult_block_block().

template<typename number >
template<typename block_number , typename nonblock_number >
void BlockSparseMatrix< number >::Tvmult ( BlockVector< block_number > &  dst,
const Vector< nonblock_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block row.

References BlockMatrixBase< SparseMatrix< number > >::Tvmult_block_nonblock().

template<typename number >
template<typename block_number , typename nonblock_number >
void BlockSparseMatrix< number >::Tvmult ( Vector< nonblock_number > &  dst,
const BlockVector< block_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block column.

References BlockMatrixBase< SparseMatrix< number > >::Tvmult_nonblock_block().

template<typename number >
template<typename nonblock_number >
void BlockSparseMatrix< number >::Tvmult ( Vector< nonblock_number > &  dst,
const Vector< nonblock_number > &  src 
) const [inline]

Matrix-vector multiplication. Just like the previous function, but only applicable if the matrix has only one block.

References BlockMatrixBase< SparseMatrix< number > >::Tvmult_nonblock_nonblock().

template<typename number >
template<class BlockVectorType >
void BlockSparseMatrix< number >::precondition_Jacobi ( BlockVectorType &  dst,
const BlockVectorType &  src,
const number  omega = 1. 
) const [inline]

Apply the Jacobi preconditioner, which multiplies every element of the src vector by the inverse of the respective diagonal element and multiplies the result with the relaxation parameter omega.

All diagonal blocks must be square matrices for this operation.

References Assert, BlockMatrixBase< SparseMatrix< number > >::block(), BlockMatrixBase< SparseMatrix< number > >::n_block_cols(), BlockMatrixBase< SparseMatrix< number > >::n_block_rows(), and SparseMatrix< number >::precondition_Jacobi().

template<typename number >
template<typename number2 >
void BlockSparseMatrix< number >::precondition_Jacobi ( Vector< number2 > &  dst,
const Vector< number2 > &  src,
const number  omega = 1. 
) const [inline]

template<typename number>
void BlockSparseMatrix< number >::print_formatted ( std::ostream &  out,
const unsigned int  precision = 3,
const bool  scientific = true,
const unsigned int  width = 0,
const char *  zero_string = " ",
const double  denominator = 1. 
) const

Print the matrix in the usual format, i.e. as a matrix and not as a list of nonzero elements. For better readability, elements not in the matrix are displayed as empty space, while matrix elements which are explicitly set to zero are displayed as such.

The parameters allow for a flexible setting of the output format: precision and scientific are used to determine the number format, where scientific = false means fixed point notation. A zero entry for width makes the function compute a width, but it may be changed to a positive value, if output is crude.

Additionally, a character for an empty value may be specified.

Finally, the whole matrix can be multiplied with a common denominator to produce more readable output, even integers.

Attention:
This function may produce large amounts of output if applied to a large matrix!

template<typename number>
const BlockSparsityPattern& BlockSparseMatrix< number >::get_sparsity_pattern (  )  const

Return a (constant) reference to the underlying sparsity pattern of this matrix.

Though the return value is declared const, you should be aware that it may change if you call any nonconstant function of objects which operate on it.

template<typename number>
unsigned int BlockSparseMatrix< number >::memory_consumption (  )  const

Determine an estimate for the memory consumption (in bytes) of this object.


Member Data Documentation

template<typename number>
SmartPointer<const BlockSparsityPattern> BlockSparseMatrix< number >::sparsity_pattern [private]

Pointer to the block sparsity pattern used for this matrix. In order to guarantee that it is not deleted while still in use, we subscribe to it using the SmartPointer class.


The documentation for this class was generated from the following file:

deal.II documentation generated on Sat Aug 15 16:51:40 2009 by doxygen 1.5.9