AMuSE
      Algebraic Multigrid for Stokes-type Equations


AMuSE is a C++-software package for solving block-systems which arise when discretizing Stokes- or Navier-Stokes- (resp. Oseen-) equations.  It is still research code, thus we do not provide a downloadable, ready to use version. But this is one of the aims for 2004, so if you are interested keep checking.

AMuSE was developed mainly by Markus Wabro. It is based on the mesh generator and AMG solver for potential equation and plain strain elasticity problems NAOMI by Ferdinand Kickinger and was also contributed to by Christoph Reisinger.

We want to emphasize that there may be faster codes than ours for some of the methods used (in fact, we are very sure that there are), many modern and efficient programming techniques (e.g. expression templates, cache aware programming, etc.) or parallelization were not applied. But the aim was not to develop a code which is the fastest for one method, but to have a tool to compare various methods using the same basic programming environment. Thus, we do not to compare different implementations but really different methods. Therefore it may not be sensible to look at the absolute timings presented in the sections with numerical results, but only to compare different timings for different methods.

We will now shortly sketch the structure of AMuSE, where we will use typewriter font for expressions directly related to the source code of the package.


Structure

Figure 1.1: The general structure of AMuSE. More complex dependencies (e.g. due to moving meshes, etc.) were omitted in this figure.
\begin{figure}\centering\psfrag{MeshHandler}{\texttt{MeshHandler}}\psfrag{F...
...epsfig{file=amuse_structure.eps,width=0.95\textwidth}
\vspace{7pt}\end{figure}
The structure of the program is sketched in Figure 1.1. The central part (at least concerning this thesis) is the block-system solver, its components are described in Figure 1.2.
Figure 1.2: The block-system-solvers are implemented as derived classes of the base AMuSE_BlockSolver. Each one (except the direct solvers) can use a preconditioner, i.e. an object which is derived from AMuSE_BlockPrecond. And the preconditioners (which use some AMG solver) can use and manipulate the structures needed for an AMG method.
AMuSE_BlockSolver
AMuSE_BlockPrecond
AMG `tools'
Richardson,
e.g. CoupledAMG,
AMuSE_GridTransfer
GMRES, <-

<->
AMuSE_BlockSmoother
BiCGstab,


AMuSE_EllipticSmoother
SIMPLE,



direct,...



The following external libraries and packages are used in parts of the program:


Matrices

AMuSE provides several sparse matrix classes which are substantial for the components described above. As some non-standard ideas are used for their construction, we will sketch them in this section.

The basic (templated) class is AMuSE_SparseMatrixData< T >, where elements of type T are stored in a similar way as compressed row storage (CRS) format, the only difference is, that we use separate arrays for the element and index data of each single row, not one long array for all elements. The template parameter T could be a scalar type like float or double or again a small matrix (class AMuSE_SmallMatrix< T, m, n >, where T is the type of the entries and m and n are the row and column dimensions). This is used to store block matrices like

$\displaystyle \begin{pmatrix}
A^{1,1} & A^{1,2} & \cdots & A^{1,j} \\
A^{2,1} ...
...dots & \cdots & \cdots \\
A^{j,1} & A^{j,2} & \cdots & A^{j,j}
\end{pmatrix},
$
with $ k\times k$ blocks $ A^{l,m}$ ($ k\gg j$) with similar sparsity pattern, efficiently as
$\displaystyle \begin{pmatrix}
a^{1,1} & a^{1,2} & \cdots & a^{1,k} \\
a^{2,1} ...
... & \cdots & \cdots \\
a^{k,1} & a^{k,2} & \cdots & a^{k,k} \\
\end{pmatrix},
$
with small $ j\times j$ matrices $ a^{l,m}$, where
$\displaystyle (a^{l,m})_{a,b} = (A^{a,b})_{l,m}.
$
The AMuSE_SparseMatrixData< T > class is only used for the storage of sparse matrices. The `mathematical' objects (which can be multiplied with vectors, `inverted', etc.) are of type AMuSE_SparseMatrix< T >.

The next generalization AMuSE_MaskedSparseMatrix< T > can be understood in the following way. Assume we want to store the matrix $ A$ of the Oseen linearized problem, which for example in 3D in general has the form

$\displaystyle \begin{pmatrix}\bar{A} & & \\ & \bar{A} & \\ & & \bar{A} \end{pmatrix}.$ (1.1)

Saving it as AMuSE_SparseMatrix< AMuSE_SmallMatrix< double, 3, 3 > > would be a waste of computer memory, thus it is saved as AMuSE_SparseMatrix< double >. For certain types of boundary conditions, e.g. symmetry planes, matrix $ A$ does not totally fit structure (1.1), some entries differ in the three diagonal blocks but most do not. Using for example AMuSE_MaskedSparseMatrix< AMuSE_SmallMatrix< double, 3, 3 > > hides this problem from the user. From outside it behaves like AMuSE_SparseMatrix< AMuSE_SmallMatrix< double, 3, 3 > >, but internally it tries to use and save only double instead of AMuSE_SmallMatrix< double, 3, 3 > elements.




This document was generated using the LaTeX2HTML translator Version 2002-2 (1.70)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html -split 0 main.tex

The translation was initiated by Markus Wabro on 2004-01-12


[main page: http://www.numa.uni-linz.ac.at  ]  [back to research  ]   [back to AMG Project  ]