jabble
Class FullMultigrid

java.lang.Object
  jabble.Evolver
      jabble.Multigrid
          jabble.FullMultigrid

public abstract class FullMultigrid
extends Multigrid

Adds the linear Multigrid V-Cycle to implement FullMultigrid.

The V-Cycle algorithm

Given Lu=f, where L is a linear differential operator, u the unknown field and f a given field, the V-Cycle algorithm is defined as:

u^h = VCycle(u^h, h, N, f ^h, v₁, v₂):

1. If N == 2, solve L^h u^h = f ^h and return u^h.
2. u^h = Relax(u^h, h, N, f ^h, v₁);
   relax v₁ times.
3. r^h = f ^h - L^h u^h;
   compute residual field.
4. f ^2h = I^2h_h r^h;
   restrict residual.
5. u^2h = 0;
   set u^2h to zero, including boundary conditions.
6. u^2h = VCycle(u^2h, 2h, N/2, f ^2h, v₁, v₂);
   recursive call.
7. u^h = u^h + I ^h_2h u^2h;
   interpolate and add correction.
8. u^h = Relax(u^h, h, N, f ^h, v₂);
   relax v₂ times.
9. Return u^h.

where:

• u^h is the solution field with step h, and u^2h is the field quantized with step 2h (the coarser field, the field at the next level of multigrid)
• N is the number of point along one direction of the grid
• f ^h is the source field
• v₁ and v₂ are the parameters for the V-Cycle
• I^2h_h is the restriction operator, that transform a fine field (with step h) to a coarse field (with step 2h).
• I ^h_2h is the prolongation operator.

In the Jabble framework, this class will take care of this algorithm and rely on a first Evolver to implement the Relax for steps 2 and 8, and a second Evolver (possibly the same as the first) for the exact solution at step 1. Therefore, to use an object of this class, one will need to specify:

• an exactSolutionEvolver, used for step 1. This is done through the constructor.
• a relaxationEvolver, used for steps 2 and 8. This is done through the constructor. If only one evolver is given, the same is used as both relaxationEvolver and exactSolutionEvolver.
• which fields need to be restricted and prolonged. This is done through the constructor.
• the implementation of how to calculate the residual and calculate the correction. This is done by implementing the l() method which should compute the L operator.

Other details:

• v₁ and v₂ correspond to the bean properties nIterationsPreRestriction and nIterationsPostProlongation. The defaults are 2 and 1 respectively.
• The exact solution (step 1) is implemented through the exactSolutionEvolver, which is run for nIterationsExact (default 3).

The following is a sample code for a FullMultigrid class that solves the Poisson equation d²phi / dx² = rho :

public class PoissonCartesianFMG extends FullMultigrid {

     // Creates FullMultigrid using PoissonCartesianGS as both the
     // relaxationEvolver and the exactSolutionEvolver.
     // "phi" is the field to be solved and "rho" is the
     // source field.
     public PoissonCartesianFMG() {
         super(new PoissonCartesianGS(), "phi", "rho");
     }

     // Fields used while computing residual and correction
     Field phi;

     // Calculates the L operator from phi
     public double l(Point point) {
         return laplacianBulk(phi);
     }
 }

Reference:

• Irad Yavneh, Why Multigrid Methods are so efficient, Computing in Science & Engineering, Nov/Dec 2006
• Numerical Recipies in C, 19.6

Nested Class Summary

Nested classes/interfaces inherited from class jabble.Multigrid

Multigrid.VCycle

Field Summary

Fields inherited from class jabble.Multigrid

f, u, vCycleProlongOperator, vCycleRestrictOperator

Fields inherited from class jabble.Evolver

constantsMap, dDirs, fieldArrayMap, fieldMap, grid, stopTrigger

Constructor Summary

FullMultigrid(Evolver evolver, java.lang.String u, java.lang.String f)
Creates a new MultiGrid evolver on top of the given evolver.

Method Summary

abstract double	l(Point point)
java.lang.String	toString() The String representation of the MultiGrid evolver, which include the toString() of the wrapped evolver.
protected void	vCycleProlong(java.util.List<Slice> coarseSlices, java.util.List<Slice> fineSlices)
protected void	vCycleRestrict(java.util.List<Slice> coarseSlices, java.util.List<Slice> fineSlices)

Methods inherited from class jabble.Multigrid

calculateNewFields, evolve, evolve, getExactSolutionEvolver, getNIterationsExact, getNIterationsPostPrologation, getNIterationsPreRestriction, getNPreviousSlicesNeeded, getNVCycleIterations, getRelaxationEvolver, getVCycleEvolver, prolong, restrict, setNIterationsExact, setNIterationsPostPrologation, setNIterationsPreRestriction, setNVCycleIterations, setupRestrictSlices

Methods inherited from class jabble.Evolver

evolve, initializeFieldArray, initializeFieldArray, skipBoundaryPoint

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

FullMultigrid

public FullMultigrid(Evolver evolver,
                     java.lang.String u,
                     java.lang.String f)

Creates a new MultiGrid evolver on top of the given evolver.

Parameters:

evolver - this evolver will be used by MultiGrid to actually solve the equations

Method Detail

l

public abstract double l(Point point)

vCycleRestrict

protected void vCycleRestrict(java.util.List<Slice> coarseSlices,
                              java.util.List<Slice> fineSlices)

Specified by:

vCycleRestrict in class Multigrid

vCycleProlong

protected void vCycleProlong(java.util.List<Slice> coarseSlices,
                             java.util.List<Slice> fineSlices)

Specified by:

vCycleProlong in class Multigrid

toString

public java.lang.String toString()

Description copied from class: Multigrid

The String representation of the MultiGrid evolver, which include the toString() of the wrapped evolver.

Overrides:

toString in class Multigrid

Returns:

String representation of the evolver