jabble
Class FAS

java.lang.Object
  jabble.Evolver
      jabble.Multigrid
          jabble.FAS

public abstract class FAS
extends Multigrid

Implements FAS (Full Approximation Storage).

The FAS V-Cycle algorithm

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

u^h = FASVCycle(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. u^2h = I^2h_h u^h;
   compute u for the coarser grid.
4. f ^2h = I^2h_h f ^h; + L^h u^h - I^2h_h L^h u^h;
   compute f for the coarser grid.
5. u^2h = VCycle(u^2h, 2h, N/2, f ^2h, v₁, v₂);
   recursive call.
6. u^h = u^h + I ^h_2h ( u^2h - I^2h_h u^h );
   calculate and add correction.
7. u^h = Relax(u^h, h, N, f ^h, v₂);
   relax v₂ times.
8. 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 7, 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 7. 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 non-linear equation d²phi / dx² + phi² = rho :

public class NonlinearEllipticCartesianFAS extends FAS {

     public NonlinearEllipticCartesianFAS() {
         // Uses the Gauss-Seidel method for both relaxation and correct solution
         // "phi" is the Field to solve for and "rho" is the source field
         super(new NonlinearEllipticCartesianGS(), "phi", "rho");
     }

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

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

Reference:

• 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

FAS(Evolver evolver, java.lang.String u, java.lang.String f)

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

FAS

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

Method Detail

vCycleRestrict

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

Specified by:

vCycleRestrict in class Multigrid

l

public abstract double l(Point point)

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