TSGLLE#

DAE solver using implicit General Linear methods [BJW07] [But16]

Options Database Keys#

-ts_gl_type - the class of general linear method (irks)
-ts_gl_rtol - relative error
-ts_gl_atol - absolute error
-ts_gl_min_order
- minimum order method to consider (default=1)
-ts_gl_max_order
- maximum order method to consider (default=3)
-ts_gl_start_order
- order of starting method (default=1)
-ts_gl_complete - method to use for completing the step (rescale-and-modify or rescale)
-ts_adapt_type - adaptive controller to use (none step both)

Notes#

These methods contain Runge-Kutta and multistep schemes as special cases. These special cases have some fundamental limitations. For example, diagonally implicit Runge-Kutta cannot have stage order greater than 1 which limits their applicability to very stiff systems. Meanwhile, multistep methods cannot be A-stable for order greater than 2 and BDF are not 0-stable for order greater than 6. GL methods can be A- and L-stable with arbitrarily high stage order and reliable error estimates for both 1 and 2 orders higher to facilitate adaptive step sizes and adaptive order schemes. All this is possible while preserving a singly diagonally implicit structure.

This integrator can be applied to DAE.

Diagonally implicit general linear (DIGL) methods are a generalization of diagonally implicit Runge-Kutta (DIRK). They are represented by the tableau

  A  |  U
  -------
  B  |  V

combined with a vector c of abscissa. “Diagonally implicit” means that $A$ is lower triangular. A step of the general method reads

\begin{align*} [ Y ] = [A U] [ Y' ] \\ [X^k] = [B V] [X^{k-1}] \end{align*}

where Y is the multivector of stage values, $Y'$ is the multivector of stage derivatives, $X^k$ is the Nordsieck vector of the solution at step $k$ . The Nordsieck vector consists of the first $r$ moments of the solution, given by

X = [x_0,x_1,...,x_{r-1}] = [x, h x', h^2 x'', ..., h^{r-1} x^{(r-1)} ]

If $A$ is lower triangular, we can solve the stages $(Y, Y')$ sequentially

y_i = h \sum_{j=0}^{s-1} (a_{ij} y'_j) + \sum_{j=0}^{r-1} u_{ij} x_j, \, \, i=0,...,{s-1}

and then construct the pieces to carry to the next step

xx_i = h \sum_{j=0}^{s-1} b_{ij} y'_j + \sum_{j=0}^{r-1} v_{ij} x_j, \, \, i=0,...,{r-1}

Note that when the equations are cast in implicit form, we are using the stage equation to define $y'_i$ in terms of $y_i$ and known stuff ( $y_j$ for $j<i$ and $x_j$ for all $j$ ).

Error estimation

At present, the most attractive GL methods for stiff problems are singly diagonally implicit schemes which posses Inherent Runge-Kutta Stability (TSIRKS). These methods have $r=s$ , the number of items passed between steps is equal to the number of stages. The order and stage-order are one less than the number of stages. We use the error estimates in the 2007 paper which provide the following estimates

\begin{align*} h^{p+1} X^{(p+1)} = \phi_0^T Y' + [0 \psi_0^T] Xold \\ h^{p+2} X^{(p+2)} = \phi_1^T Y' + [0 \psi_1^T] Xold \\ h^{p+2} (dx'/dx) X^{(p+1)} = \phi_2^T Y' + [0 \psi_2^T] Xold \end{align*}

These estimates are accurate to $O(h^{p+3})$ .

Changing the step size

Uses the generalized “rescale and modify” scheme, see equation (4.5) of [BJW07].

References#

[BJW07] (1,2)

J.C. Butcher, Z. Jackiewicz, and W.M. Wright. Error propagation of general linear methods for ordinary differential equations. Journal of Complexity, 23(4-6):560–580, 2007. doi:10.1016/j.jco.2007.01.009.

[But16]

John Charles Butcher. Numerical methods for ordinary differential equations. John Wiley & Sons, 2016.

Level#

beginner

Location#

src/ts/impls/implicit/glle/glle.c

Index of all TS routines
Table of Contents for all manual pages
Index of all manual pages