# Difference between revisions of "Solution of the Blatter-Pattyn model"

(→The Jacobian Free Approach) |
(→The Jacobian Free Approach) |
||

Line 235: | Line 235: | ||

− | Finally, note that the right-hand side of the above equation | + | Finally, note that the right-hand side of the above equation is equal to |

Line 241: | Line 241: | ||

v_{1}\frac{\partial F_{1}}{\partial u_{1}}+v_{2}\frac{\partial F_{1}}{\partial u_{2}} \\ | v_{1}\frac{\partial F_{1}}{\partial u_{1}}+v_{2}\frac{\partial F_{1}}{\partial u_{2}} \\ | ||

v_{1}\frac{\partial F_{2}}{\partial u_{1}}+v_{2}\frac{\partial F_{2}}{\partial u_{2}} \\ | v_{1}\frac{\partial F_{2}}{\partial u_{1}}+v_{2}\frac{\partial F_{2}}{\partial u_{2}} \\ | ||

− | \end{matrix} \right]</math> | + | \end{matrix} \right]</math>, |

− | + | with the Jacobian matrix given by | |

+ | |||

+ | |||

+ | |||

+ | <math>\mathbf{J}=\left[ \begin{matrix} | ||

+ | \frac{\partial F_{1}}{\partial u_{1}} & \frac{\partial F_{1}}{\partial u_{2}} \\ | ||

+ | \frac{\partial F_{2}}{\partial u_{1}} & \frac{\partial F_{2}}{\partial u_{2}} \\ | ||

+ | \end{matrix} \right]</math>. |

## Revision as of 15:26, 14 March 2011

## Contents |

### Governing Equations

The final form of the equations we'd like to solve is:

### Coordinate Transform

For ice sheet modeling, it is convenient to recast the governing equations using a dimensionless, stretched vertical coordinate (often called a *sigma coordinates*). The stretched vertical coordinate is defined as:

This means that at the surface of the ice sheet , and at the base regardless of the ice thickness. As a result of this transformation, a coordinate is mapped to . This means that function derivatives must be re-written (using as an example) as:

Similarly for and . We can simplify this by assuming that

and

.

This assumption is valid if the bed and surface gradients are not too large. This simplifies the above to:

Rescaling parameters , , , , and are defined. For the *x* derivative case (the *y* derivative case is analogous) we have

Using these, expressions for the *x* derivatives become:

where hatted values refer to the coordinate directions in sigma coordinates. Similarly, the first cross-stress term on the RHS is given by

One term has become five terms and each one of those is pretty ugly looking on its own. Luckily, there is a lot of symmetry here. Notice that if we wanted to design subroutines to discretize the terms on the RHS, we could re-use a lot of them by either applying them to the correct velocity component (to either the *U* or the *V* discretization) or by passing the appropriate arguments (by passing either the grid spacing in the *X* direction or the *Y* direction, where appropriate).

A similar transform is applied to each of the terms in the governing equations given above. At any point within the grid, the grid spacing, coordinate transform, and viscosity information associated with the unknown velocity components (*U* and *V*) is made discrete using finite differences. This information ultimately equates to coefficients on the unknown velocities, allowing the governing equations over the entire grid (with appropriate discretizations for boundary conditions) to be recast as a system of *n* equations in *n* unknowns. In turn, this system is solved using standard linear algebraic methods for large, [sparse] systems of equations.

### Operating Splitting

In the governing equations given above, note that for the *x* equation we have moved all terms containing gradients in *v* to the right-hand side (RHS) (and vice-versa for the *y* equation).

This allows us to solve the equations using an *operator splitting* approach; for the *x* equation, we treat *v* as known (where we take the values of *v* from the previous iteration, as discussed further below) and solve for *u*, and vice versa when we solve the *y* equation for *v*. The "splitting" refers to the fact that we are breaking the multi-dimensional divergence operation into two steps; rather than solving one big matrix equation for *u* and *v* simultaneously, we solve two smaller matrix equations in sequence with one of the unknowns treated as a known "source" term. This procedure was probably more common and important years ago when it was desirable to keep the matrix equations as small as possible for memory management issues. On today's machines, with fewer memory limitations (in particular when dealing with codes designed to run on parallel, distributed memory architectures) this splitting is not necessary and may even lead to some undesirable numerical side effects (i.e. a slow-down in the convergence of iterations used to treat nonlinearity in the governing equations).

A general matrix form of the "split" equations, where coefficients on the *u* and *v* velocity components (i.e. viscosity, grid spacing, scalars) are contained in the block matrices **A**, is given by

where the **uu** subscript denotes block matrices containing coefficients for gradients on *u* in the equation for the *x* component of velocity (i.e. *u*). The subscript **uv** denotes block matrices containing coefficients for gradients on *v* in the equation for the *x* component of velocity (and similarly for the **vv** and **vu** subscripts). On the right-hand side, the single subscripts **u** and **v** are attached to the geometric source terms for the *x* and *y* components of velocity, respectively.

### Solution of the Non-linear System Through a Fixed Point Iteration

The non-linearity in the equations - the fact that the coefficients on the velocity components (the viscosity) are dependent on the velocity (or more specifically, the velocity gradients) - is handled through a "fixed-point iteration". A general fixed point iteration for a vector of unknowns *u* can be written as

,

where *k* is the index for the *u* being solved for and **B** is a matrix operation performed on the components of *u* obtained at the previous iteration, *k-1*. The "fixed point" occurs when the values of *u* at *k* and *k-1* are equal to within some given tolerance (at which point the iteration process is halted). CISM has options for implementing both "Picard" and "Newton"-based fixed-point iterations. For the Picard iteration (standard in CISM), the matrix coefficients with a velocity dependence are simply based on the velocities obtained at the previous iteration. In most cases, this equates to using velocities obtained from the previous iteration to calculate the strain rate components that go into the calculation of the effective viscosity, .

### Final Matrix Form

When accounting for both the operator splitting and the Picard iteration on the effective viscosity, the final form of the matrix equations solved in CISM becomes

where the index *k* denotes an unknown value being solved for during the current non-linear iteration and the index *k*-1 denotes a lagged value taken from solution at the end of the previous non-linear iteration (again, here the lagging is primarily with respect to the effective viscosity, the value of which is calculated using velocity gradients obtained at the end of the previous iteration). The final form of the matrix equations given above represents a linear system; for the solution at any particular nonlinear iteration *k*, all of the coefficients on the unknown velocity components *u* and *v* are held "frozen" during the solution of the linear system. This linear system can be solved using any practical method. For large, sparse systems, some variant on the iterative conjugate gradient method (e.g. BiCG, GMRES) is generally the most efficient. In this case the linear system is not solved exactly but is solved to within some small tolerance of the "true" solution.

### Newton-based Methods for Solutions of the Non-linear System

Without any operator splitting, the generic matrix form of the equations to be solved can be written as

.

The linearized form of the equations to be solved using the Picard solution can be written as

.

The full nonlinear system to be solved can be written as

with the solution for the uknown vector *u* given by

.

A Newton-based solution for this system of equations, based on a first-order Taylor series expansion about the solution for *u* at iteration *k-1*, can be written as

,

where

is the system Jacobian with individual components give by

and

is the Newton update to be solved for. One method for doing so is by solving

.

The advantage of Newton-based methods is that, with a good initial guess for the solution, convergence rates are very often quadratic (e.g. the residual decreases quadratically, so that at iteration *k* one has a residual of 0.1, at iteration *k+1*, a residual of 0.01, and at iteration *k+2* a residual of 0.0001), whereas Picard-based iterations are much slower to converge.

### The Jacobian Free Approach

In practice, the model Jacobian may either be too difficult or to expensive too form. A "Jacobian Free Newton-Krylov" (JFNK) approach has recently been implemented in CISM (Leimieux et al., submitted to *JCP*), largely following methods discussed in Knoll and Keyes (2004). The crux of the method comes from noting that, when solving the last equation above using a Krylov method (e.g. Conjugate Gradients, GMRES, etc.) the solution for the Newton update is taken from a combination of Krylov vectors that span the subspace

.

This implies that, when using a Krylov method, one only ever needs to calculate matrix vector products of the form when building up the subspace that approximates the solution vector .

Following Knoll and Keyes (2004), note that the necessary matrix vector products can be approximated through nonlinear function evaluations and a perturbation as

.

It is not immediately obvious why this approximation is valid. To verify this, take a few steps back and consider a nonlinear system of equations of two variables, *u1* and *u2*. The right-hand side of the above equation can be expanded as

.

A first-order Taylor series expansion approximation to this is given by

,

which collapses to

.

Finally, note that the right-hand side of the above equation is equal to

,

with the Jacobian matrix given by

.