TSGLLE#
DAE solver using implicit General Linear methods 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.
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#
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
[ Y ] = [A U] [ Y' ]
[X^k] = [B V] [X^{k-1}]
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
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
These estimates are accurate to O(h^{p+3}).
Changing the step size
We use the generalized “rescale and modify” scheme, see equation (4.5) of the 2007 paper.
References#
**** -*** John Butcher and Z. Jackieweicz and W. Wright, On error propagation in general linear methods for ordinary differential equations, Journal of Complexity, Vol 23, 2007.
**** -*** John Butcher, Numerical methods for ordinary differential equations, second edition, Wiley, 2009.
See Also#
TS: Scalable ODE and DAE Solvers, TSCreate()
, TS
, TSSetType()
, TSType
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