## Free Software

A number of software
packages are stored on MGNet. Some are public domain, some are copyrighted, and some might
be copyrighted someday (all rights reserved). When in doubt, contact the author(s) of the
package(s) you are interested in.

Please remember that this is
freely distributed software. Hence, the amount of support you receive will probably be
limited.

If you have a multigrid,
domain decomposition, or parallel code or package that you would like to contribute,
please send e-mail to

BDD

Jan Mandel's balancing domain decomposition
code. This is in the jmandel subdirectory.

Barsky

Sandra Barsky's code,
written in C, which solves non-linear
time-dependent 2-D eqns. In particular, the equation should have the
form (d/dt)u= (\nabla^2) u + g(x,y,u) + f(x,y)
with periodic boundary conditions. The function g is easily tunable.
The code is written as a primarily instructional
code for a student who might have some familiarity
with linear multigrid, and would want a slightly more general
approach, or a student who can solve a linear boundary equation, but
is now looking to include time.
There are no detailed explanations of what
restriction or prolongation do, but more details are
provided in how the linearization occurs
and what happens as a function of time.

BOXMG

A single processor black box
multigrid Fortran-77 code written by Victor Bandy and Joel
Dendy. This might be public domain software, but it might be owned by the US
Department of Energy (DOE). Check with the authors.

Borzi

Alfio Borzi's public domain Fortran-77 codes.
Controlla is for optimality systems and is a full multigrid method for
the solution of an optimality system arising from optimal control of the
solid fuel ignition model.
Santafe is for open-loop optimal for open-loop optimal control of
time-dependent reaction-diffusion systems. The code is designed to solve
for tracking and terminal observation problems also in combination with
receding horizon techniques.

Bunner

A public domain, parallel
processor replacement Fortran-77 code for Mudpack written by Bernard Bunner. It requires both MPI and the C
preprocessor. This code features staggered grids, rectangular domains, constant mesh
spacing in 2 or 3 dimensions, V or W cycling, full weighting for the restriction and
bilinear interpolation for the correction, either vertex-centered or cell-centered
operations, and periodic, Neumann, or Dirichlet boundary conditions.

DAGH

A one or more processor C++
copyrighted library written by M. Parashar and
J. C. Browne. DAGH (Distributed Adaptive
Grid Hierarchy) provides a program development infrastructure for implementation of
solutions of partial differential equations using adaptive mesh refinement algorithms. The
principles of hierarchical abstraction and separation of concerns were incorporated into
the development of DAGH. The code solves problems in two and three dimensions.
It includes multigrid as an option.

Douglas

A one or more processor
public domain Fortran-77 code written by Craig
Douglas. This requires MPI and the preprocessor m4. Some simple example
multigrid codes using MPI for message passing are provided.

Featflow

A single processor Fortran-77
copyrighted code written by Stefan Turek
et al. FEATFLOW is designed for the following MGNet Codesthree classes of applications:

- Education of students
- Scientific research
- Industrial applications

FEATFLOW is both a user oriented as well as a general purpose subroutine system for the
numerical solution of the incompressible Navier-Stokes equations in two and three space
dimensions. It is based on the packages FEAT2D and FEAT3D.

Fortuna

A public domain, single
processor code written by Armando de Oliveira
Fortuna. This is a tutorial solver for the Laplace/Poisson equations which
allows the user to select between multigrid, Line-SOR, or Point-SOR. It is a nice tool to
introduce multigrid to new students. They can see for themselves how multigrid
compares to SOR.

GMD

The copyrighted Fortran-77
GMD multigrid solvers MG00 and MG01. MG00 was written by Hartmut Foerster and Kristian Witsch. MG01 was
written by Klaus Stueben.

GRUMMP

This is a code written by Carl Ollivier-Gooch. The goal of the GRUMMP project is
to develop automatic mesh generation software for unstructured meshes with mixed element
types. The software will be able to produce high-quality meshes which meet user-defined
mesh density requirements, using elements appropriate for the geometry and physics of a
particular problem. We envision a system in which common types of physical problems have
pre-defined mesh sizing and element aspect ratio functions, allowing easy generation of
meshes for these applications areas. For flexibility and generality, the user will also be
able to prescribe these functions (for totally different applications) or modify the
pre-defined behaviors (to provide a quality mesh in the wake of an airplane wing, for
example).

Integra

A single processor public domain Fortran-77 program by
Alfio Borzi to solve
nonlinear integral equations using a multigrid method.

Kaskade

A single processor
copyrighted C program by Rainer Roitsch, Bodo Erdmann, and Jens Lang.
The copyright owner is Konrad-Zuse Zentrum (ZIB). Kaskade is a finite
element, adaptive mesh code for solving problems in two and three dimensions.

LASPack

This is a copyrighted
ANSI C program written by Tomas
Skalicky. LASPack is a package for solving large sparse systems of linear
equations like those which arise from discretization of partial differential equations. It
contains classical as well as selected state of the art algorithms which are commonly used
for large sparse systems such as conjugate gradient-like methods for non-symmetric systems
(CGN, GMRES, BiCG, QMR, CGS, and BiCGStab) and multilevel methods such as multigrid and
conjugate gradient method preconditioned by either a multigrid or BPX preconditioner. Two
sets of documentation are included: PostScript and html formats.

LPARX

This is a one or more
processor copyrighted C++ library written by Scott R. Kohn
and Scott B. Baden. The copyright owners are
the two authors and The Regents of the University of California. LPARX provides
efficient run-time support for dynamic, non-uniform scientific calculations running on
MIMD distributed memory architectures. It extends HPF's data decomposition model to
provide support for dynamic, block irregular data structures. LPARX represents data
decompositions as first-class objects and expresses data dependencies in a manner which is
logically independent of data decomposition and problem dimension.

Madpack2

A public domain single
processor family of solvers written by Craig
Douglas. There are separate versions in C and Fortran-77. This is an
abstract multilevel solver. It is PDE, domain, and discretization independent.
Examples from two and three dimensions are provided.

Madpack5

A public domain one or more
processor object oriented code written primarily by Craig Douglas. There have been several
other contributors (e.g., David Fyfe and Juan Santos), some of whom would like to remain
anonymous. The parallel parts of the code is available upon request only.

Madpack5 is an abstract
multilevel solver. It is PDE, domain, and discretization independent. It only handles
linear problems, however. A paper describing the code is available on MGNet. Madpack5 is an object
oriented code. The user interface is written in C. Most of the solvers are written in
Fortran-77+m4. The same calling sequence is used independent of the data's type (real and
complex, single and double precision, user defined are supported). The user interface
builds all of the truly nasty data structures used internally by the code.

Mandel

A single processor
copyrighted Fortran-77 code by Jan Mandel
for balancing domain decomposition. Jan and Solvers International own the
copyright.

MGD9V

This is a copyrighted single
processor Fortran-77 code written by Paul M. DeZeeuw.
The copyright owner is probably CWI. MGD9V is a black box multigrid solver that
assumes that a general second order elliptic problem in two dimensions has been
discretized using a nine point operator.

MGGHAT

This is a (mostly) public
domain, single processor Fortran-77 code written by Bill Mitchell. MGGHAT (Multi Grid Galerkin
Hierarchical Adaptive Triangles), version 1.1, is an adaptive grid refinement multigrid
code for solving linear second order elliptic partial differential equations on polygonal
domains with linear, quadratic, or cubic elements over triangles.

MGLab

This is a public domain set
of Matlab functions written by James Bordner and Faisal Saied. MGLab is an interactive
environment for experimenting with multigrid algorithms. MGLab can solve two dimensional
elliptic partial differential equations using finite differences and includes several
built-in problems (Poisson, Helmholtz, discontinuous coefficient problems, and
nonselfadjoint problems). A number of parameters controlling the V cycle can be set using
a point and click mechanism. The menu based user interface also allows a choice of several
Krylov subspace accelerators (PCG, GMRES(k), and BiCGSTAB). The package exploits Matlab's
visualization and sparse matrix features. It has also been structured to be extensible.

MUDPACK

This is copyrighted, licensed
software in Fortran for one or more processors, written by John Adams. MUDPACK 4.0 replaces and is
incompatible with earlier versions. The software includes a suite of portable Fortran
programs which automatically discretize and use multigrid techniques to generate second-
and fourth-order approximations to elliptic Partial Differential Equations (PDEs) on
rectangular regions. The elliptic PDEs can be real or complex in two- and three-dimensions
with any combination of mixed derivatives, specified, or periodic boundary conditions.
Multigrid V or W cycles which use point, line(s), or planar relaxation and fully weighted
residual restriction are available for algorithm tuning to obtain optimal multigrid
performance. MUDPACK was written to avoid repeated "re-invention of the wheel"
in human code development time which can be at least as important as saving machine
cycles.

ParMGridGen

This is copyrighted C code, written by Irene Moulitsas. ParMGridGen-1.0 is a highly optimized serial and parallel library for
obtaining a sequence of successive coarse grids that are well suited for geometric multigrid methods. The quality of the elements of the
coarse grids is optimized using a multilevel framework. The parallel library is based on MPI and is portable to a
wide range of architectures.

pARMS

Yousef Saad's parallel Algebraic Recursive Multilevel Solvers.

PHAML

Parallel Hierarchical Adaptive
MultiLevel (PHAML) is a Fortran 90
module for the solution of second order linear elliptic partial
differential equations with Dirichlet,
Neumann (natural) or Mixed boundary conditions.PLTMG

A single processor
copyrighted Fortran-77 code written by Randy Bank.
PLTMG (Piecewise Linear Triangle Multi-Grid), version 8.1, is an adaptive multigrid
solver for two dimensional problems in general domains. There is a little bit of C
code for the graphical user interface.

UG

This is a copyrighted single
processor C code managed by Peter Bastian,
though e-mail should be sent to ug@ica3.uni-stuttgart.de.
UG is a flexible software library for the development of adaptive multigrid methods on
unstructured meshes in two or three spatial dimensions. UG implements most parts in
a problem independent way so that the software can be reused for many different
applications. In order to use the software here, you must get a license which contains the missing header file.

Vanek

This is a single processor
public domain Fortran-77 code written by Petr
Vanek. This is an algebraic multigrid solver based on smoothed aggregation. It
has fully automatic coarsening and is capable of solving structural mechanics problems.
The code is reliable if the model consists of solids and plate. Some problems with
convergence may occur in the case of very thin and curved shells.

Wesseling

A single processor public
domain Fortran-77 code written by Pieter
Wesseling. The file mglab.for is a tutorial multigrid program. It solves
elliptic boundary values in one dimension. The user may choose various multigrid cycles,
transfer operators, smoothing methods, and nested iteration, and defect correction. Cell
centered and vertex centered discretization and multigrid is included. Documentation is
included in the program. The program is written in portable Fortran-77, and has run on
MS-DOS PC's and Unix based computers. The methods used are fully described in the
following book: An Introduction to Multigrid Methods, Wiley, Chichester, 1992 by P.
Wesseling.

Wienands

LFA00_2D_scalar is a Fourier analysis program written
by
Roman Wienands in
Fortran-77. Both two and three grid analysis (LFA) for 2D
scalar partial differential equations is included. The code
supports many variants of coarsening strategies, coarse grid
discretization, prolongation, restriction, and relaxation methods. This is copyrighted by Roman Wienands, 2000.