naginterfaces.library.pde.dim2_gen_order2_rectangle¶

naginterfaces.library.pde.dim2_gen_order2_rectangle(ts, tout, dt, xmin, xmax, ymin, ymax, nx, ny, tols, tolt, pdedef, bndary, pdeiv, monitr, opti, optr, comm, itrace, ind, lenrwk=None, leniwk=None, lenlwk=None, data=None, io_manager=None, spiked_sorder='C')[source]¶

dim2_gen_order2_rectangle integrates a system of linear or nonlinear, time-dependent partial differential equations (PDEs) in two space dimensions on a rectangular domain. The method of lines is employed to reduce the PDEs to a system of ordinary differential equations (ODEs) which are solved using a backward differentiation formula (BDF) method. The resulting system of nonlinear equations is solved using a modified Newton method and a BI-CGSTAB iterative linear solver with ILU preconditioning. Local uniform grid refinement is used to improve the accuracy of the solution. dim2_gen_order2_rectangle originates from the VLUGR2 package (see Blom and Verwer (1993) and Blom et al. (1996)).

For full information please refer to the NAG Library document for d03ra

https://support.nag.com/numeric/nl/nagdoc_30.3/flhtml/d03/d03raf.html

Parameters

tsfloat

The initial value of the independent variable $t$ .

toutfloat

The final value of $t$ to which the integration is to be carried out.

dtfloat, array-like, shape $(3)$

The initial, minimum and maximum time step sizes respectively.

$d t [0]$

Specifies the initial time step size to be used on the first entry, i.e., when $i n d = 0$ . If $d t [0] = 0.0$ then the default value $d t [0] = 0.01 \times (t o u t - t s)$ is used. On subsequent entries ( $i n d = 1$ ), the value of $d t [0]$ is not referenced.

$d t [1]$

Specifies the minimum time step size to be attempted by the integrator. If $d t [1] = 0.0$ the default value $d t [1] = 10.0 \times machine precision$ is used.

$d t [2]$

Specifies the maximum time step size to be attempted by the integrator. If $d t [2] = 0.0$ the default value $d t [2] = t o u t - t s$ is used.

xminfloat

The extents of the rectangular domain in the $x$ -direction, i.e., the $x$ coordinates of the left and right boundaries respectively.

xmaxfloat

The extents of the rectangular domain in the $x$ -direction, i.e., the $x$ coordinates of the left and right boundaries respectively.

yminfloat

The extents of the rectangular domain in the $y$ -direction, i.e., the $y$ coordinates of the lower and upper boundaries respectively.

ymaxfloat

The extents of the rectangular domain in the $y$ -direction, i.e., the $y$ coordinates of the lower and upper boundaries respectively.

nxint

The number of grid points in the $x$ -direction (including the boundary points).

nyint

The number of grid points in the $y$ -direction (including the boundary points).

tolsfloat

The space tolerance used in the grid refinement strategy ( $σ$ in equation (4)). See Further Comments.

toltfloat

The time tolerance used to determine the time step size ( $τ$ in equation (7)). See Time Integration.

pdedefcallable res = pdedef(t, x, y, u, ut, ux, uy, uxx, uxy, uyy, data=None)

$p d e d e f$ must evaluate the functions $F_{j}$ , for $j = 1, 2, \dots, n p d e$ , in equation (1) which define the system of PDEs (i.e., the residuals of the resulting ODE system) at all interior points of the domain.

Values at points on the boundaries of the domain are ignored and will be overwritten by $b n d a r y$ . $p d e d e f$ is called for each subgrid in turn.

Parameters

tfloat: The current value of the independent variable $t$ .
xfloat, ndarray, shape $(npts)$: $x [i - 1]$ contains the $x$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
yfloat, ndarray, shape $(npts)$: $y [i - 1]$ contains the $y$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
ufloat, ndarray, shape $(npts, npde)$: $u [i - 1, j - 1]$ contains the value of the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
utfloat, ndarray, shape $(npts, npde)$: $u t [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial t}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uxfloat, ndarray, shape $(npts, npde)$: $u x [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial x}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uyfloat, ndarray, shape $(npts, npde)$: $u y [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial y}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uxxfloat, ndarray, shape $(npts, npde)$: $u x x [i - 1, j - 1]$ contains the value of $\frac{\partial^{2} u}{\partial x^{2}}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uxyfloat, ndarray, shape $(npts, npde)$: $u x y [i - 1, j - 1]$ contains the value of $\frac{\partial^{2} u}{\partial x \partial y}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uyyfloat, ndarray, shape $(npts, npde)$: $u y y [i - 1, j - 1]$ contains the value of $\frac{\partial^{2} u}{\partial y^{2}}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
dataarbitrary, optional, modifiable in place: User-communication data for callback functions.

Returns

resfloat, array-like, shape $(npts, npde)$: $r e s [i - 1, j - 1]$ must contain the value of $F_{j}$ , for $j = 1, 2, \dots, n p d e$ , at the $i$ th grid point, for $i = 1, 2, \dots, npts$ , although the residuals at boundary points will be ignored (and overwritten later on) and so they need not be specified here.

bndarycallable res = bndary(t, x, y, u, ut, ux, uy, lbnd, res, data=None)

$b n d a r y$ must evaluate the functions $G_{j}$ , for $j = 1, 2, \dots, n p d e$ , in equation (2) which define the boundary conditions at all boundary points of the domain.

Residuals at interior points must not be altered by this function.

Parameters

tfloat: The current value of the independent variable $t$ .
xfloat, ndarray, shape $(npts)$: $x [i - 1]$ contains the $x$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
yfloat, ndarray, shape $(npts)$: $y [i - 1]$ contains the $y$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
ufloat, ndarray, shape $(npts, npde)$: $u [i - 1, j - 1]$ contains the value of the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
utfloat, ndarray, shape $(npts, npde)$: $u t [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial t}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uxfloat, ndarray, shape $(npts, npde)$: $u x [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial x}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
uyfloat, ndarray, shape $(npts, npde)$: $u y [i - 1, j - 1]$ contains the value of $\frac{\partial u}{\partial y}$ for the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .
lbndint, ndarray, shape $(nbpts)$: $l b n d [i - 1]$ contains the grid index for the $i$ th boundary point, for $i = 1, 2, \dots, nbpts$ . Hence the $i$ th boundary point has coordinates $x [l b n d [i - 1] - 1]$ and $y [l b n d [i - 1] - 1]$ , and the corresponding solution values are $u [l b n d [i - 1] - 1, n p d e - 1]$ , etc.
resfloat, ndarray, shape $(npts, npde)$: $r e s [i - 1, j - 1]$ contains the value of $F_{j}$ , for $i = 1, 2, \dots, n p d e$ , at the $i$ th grid point, for $i = 1, 2, \dots, npts$ , as returned by $p d e d e f$ . The residuals at the boundary points will be overwritten and so need not have been set by $p d e d e f$ .
dataarbitrary, optional, modifiable in place: User-communication data for callback functions.

Returns

resfloat, array-like, shape $(npts, npde)$

$r e s [l b n d [i - 1] - 1, j - 1]$ must contain the value of $G_{j}$ , for $j = 1, 2, \dots, n p d e$ , at the $i$ th boundary point, for $i = 1, 2, \dots, nbpts$ .

Note: elements of $r e s$ corresponding to interior points must not be altered.

pdeivcallable u = pdeiv(npde, t, x, y, data=None)

$p d e i v$ must specify the initial values of the PDE components $u$ at all points in the grid. $p d e i v$ is not referenced if, on entry, $i n d = 1$ .

Parameters

npdeint: The number of PDEs in the system.
tfloat: The (initial) value of the independent variable $t$ .
xfloat, ndarray, shape $(npts)$: $x [i - 1]$ contains the $x$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
yfloat, ndarray, shape $(npts)$: $y [i - 1]$ contains the $y$ coordinate of the $i$ th grid point, for $i = 1, 2, \dots, npts$ .
dataarbitrary, optional, modifiable in place: User-communication data for callback functions.

Returns

ufloat, array-like, shape $(npts, n p d e)$: $u [i - 1, j - 1]$ must contain the value of the $j$ th PDE component at the $i$ th grid point, for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, npts$ .

monitrcallable ierr = monitr(npde, t, dt, dtnew, tlast, ngpts, xpts, ypts, lsol, sol, ierr, data=None)

$m o n i t r$ is called by dim2_gen_order2_rectangle at the end of every successful time step, and may be used to examine or print the solution or perform other tasks such as error calculations, particularly at the final time step, indicated by the argument $t l a s t$ .

The input arguments contain information about the grid and solution at all grid levels used.

$m o n i t r$ can also be used to force an immediate tidy termination of the solution process and return to the calling program.

Parameters

npdeint

The number of PDEs in the system.

tfloat

The current value of the independent variable $t$ , i.e., the time at the end of the integration step just completed.

dtfloat

The current time step size $Δ t$ , i.e., the time step size used for the integration step just completed.

dtnewfloat

The step size that will be used for the next time step.

tlastbool

Indicates if intermediate or final time step. $t l a s t = F a l s e$ for an intermediate step, $t l a s t = T r u e$ for the last call to $m o n i t r$ before returning to your program.

ngptsint, ndarray, shape $(nlev)$

$n g p t s [l - 1]$ contains the number of grid points at level $l$ , for $l = 1, 2, \dots, nlev$ .

xptsfloat, ndarray, shape $(s u m (n g p t s))$

Contains the $x$ coordinates of the grid points in each level in turn, i.e., $x [i - 1]$ , for $l = 1, 2, \dots, nlev$ , for $i = 1, 2, \dots, n g p t s [l - 1]$ .

So for level $l$ , $x [i - 1] = x p t s [k + i - 1]$ , where $k = n g p t s [0] + n g p t s [1] + \dots + n g p t s [l - 2]$ , for $l = 1, 2, \dots, nlev$ , for $i = 1, 2, \dots, n g p t s [l - 1]$ .

yptsfloat, ndarray, shape $(s u m (n g p t s))$

Contains the $y$ coordinates of the grid points in each level in turn, i.e., $y [i - 1]$ , for $l = 1, 2, \dots, nlev$ , for $i = 1, 2, \dots, n g p t s [l - 1]$ .

So for level $l$ , $y [i - 1] = y p t s [k + i - 1]$ , where $k = n g p t s [0] + n g p t s [1] + \dots + n g p t s [l - 2]$ , for $l = 1, 2, \dots, nlev$ , for $i = 1, 2, \dots, n g p t s [l - 1]$ .

lsolint, ndarray, shape $(nlev)$

$l s o l [l - 1]$ contains the pointer to the solution in $s o l$ at grid level $l$ and time $t$ . ( $l s o l [l - 1]$ actually contains the array index immediately preceding the start of the solution in $s o l$ .)

solfloat, ndarray, shape $(:)$

Contains the solution $u [n g p t s [l - 1] - 1, n p d e - 1]$ at time $t$ for each grid level $l$ in turn, positioned according to $l s o l$ , i.e., for level $l$ , $u [i - 1, j - 1] = s o l [l s o l [l - 1] + (j - 1) \times n g p t s [l - 1] + i - 1]$ , for $l = 1, 2, \dots, nlev$ , for $j = 1, 2, \dots, n p d e$ , for $i = 1, 2, \dots, n g p t s [l - 1]$ .

ierrint

Will be set to $0$ .

dataarbitrary, optional, modifiable in place

User-communication data for callback functions.

Returns

ierrint: Should be set to $1$ to force a tidy termination and an immediate return to the calling program with $e r r n o$ = 4. $i e r r$ should remain unchanged otherwise.

optiint, array-like, shape $(4)$

May be set to control various options available in the integrator.

$o p t i [0] = 0$

All the default options are employed.

$o p t i [0] > 0$

The default value of $o p t i [i - 1]$ , for $i = 2, 3, \dots, 4$ , can be obtained by setting $o p t i [i - 1] = 0$ .

$o p t i [0]$

Specifies the maximum number of grid levels allowed (including the base grid). $o p t i [0] \geq 0$ . The default value is $o p t i [0] = 3$ .

$o p t i [1]$

Specifies the maximum number of Jacobian evaluations allowed during each nonlinear equations solution. $o p t i [1] \geq 0$ . The default value is $o p t i [1] = 2$ .

$o p t i [2]$

Specifies the maximum number of Newton iterations in each nonlinear equations solution. $o p t i [2] \geq 0$ . The default value is $o p t i [2] = 10$ .

$o p t i [3]$

Specifies the maximum number of iterations in each linear equations solution. $o p t i [3] \geq 0$ . The default value is $o p t i [3] = 100$ .

optrfloat, array-like, shape $(3, npde)$

May be used to specify the optional vectors $u^{m a x}$ , $w^{s}$ and $w^{t}$ in the space and time monitors (see Further Comments).

If an optional vector is not required then all its components should be set to $1.0$ .

$o p t r [0, j - 1]$ , for $j = 1, 2, \dots, npde$ , specifies $u_{j}^{m a x}$ , the approximate maximum absolute value of the $j$ th component of $u$ , as used in (4) and (7). $o p t r [0, j - 1] > 0.0$ , for $j = 1, 2, \dots, npde$ .

$o p t r [1, j - 1]$ , for $j = 1, 2, \dots, npde$ , specifies $w_{j}^{s}$ , the weighting factors used in the space monitor (see (4)) to indicate the relative importance of the $j$ th component of $u$ on the space monitor. $o p t r [1, j - 1] \geq 0.0$ , for $j = 1, 2, \dots, npde$ .

$o p t r [2, j - 1]$ , for $j = 1, 2, \dots, npde$ , specifies $w_{j}^{t}$ , the weighting factors used in the time monitor (see (6)) to indicate the relative importance of the $j$ th component of $u$ on the time monitor. $o p t r [2, j - 1] \geq 0.0$ , for $j = 1, 2, \dots, npde$ .

commdict, communication object, modified in place

Communication structure.

On initial entry: need not be set.

itraceint

The level of trace information required from dim2_gen_order2_rectangle. $i t r a c e$ may take the value $- 1$ , $0$ , $1$ , $2$ or $3$ .

$i t r a c e = - 1$

No output is generated.

$i t r a c e = 0$

Only warning messages are printed.

$i t r a c e > 0$

Output from the underlying solver is printed. This output contains details of the time integration, the nonlinear iteration and the linear solver.

If $i t r a c e < - 1$ , $- 1$ is assumed and similarly if $i t r a c e > 3$ , $3$ is assumed.

The advisory messages are given in greater detail as $i t r a c e$ increases.

Setting $i t r a c e = 1$ allows you to monitor the progress of the integration without possibly excessive information.

indint

Must be set to $0$ or $1$ , alternatively $10$ or $11$ .

$i n d = 0$

Starts the integration in time. $p d e d e f$ is assumed to be serial.

$i n d = 1$

Continues the integration after an earlier exit from the function. In this case, only the following parameters may be reset between calls to dim2_gen_order2_rectangle: $tout$ , $dt$ , $tols$ , $tolt$ , $opti$ , $optr$ , $itrace$ and $errno$ . $p d e d e f$ is assumed to be serial.

$i n d = 10$

Starts the integration in time. $p d e d e f$ is assumed to have been parallelized by you, as described in Parallelism and Performance. In all other respects, this is equivalent to $i n d = 0$ .

$i n d = 11$

Continues the integration after an earlier exit from the function. In this case, only the following parameters may be reset between calls to dim2_gen_order2_rectangle: $tout$ , $dt$ , $tols$ , $tolt$ , $opti$ , $optr$ , $itrace$ and $errno$ . $p d e d e f$ is assumed to have been parallelized by you, as described in Parallelism and Performance. In all other respects, this is equivalent to $i n d = 1$ .

lenrwkNone or int, optional

Note: if this argument is None then a default value will be used, determined as follows: $maxpts \times n p d e \times (5 \times maxlev + 18 \times n p d e + 9) + 2 \times maxpts$ .

The required value of $l e n r w k$ cannot be determined exactly in advance, but a suggested value is

l e n r w k = maxpts \times npde \times (5 \times l + 18 \times npde + 9) + 2 \times maxpts,

where $l = o p t i [0]$ if $o p t i [0] \neq 0$ and $l = 3$ otherwise, and $maxpts$ is the expected maximum number of grid points at any one level.

If during the execution the supplied value is found to be too small then the function returns with $e r r n o$ = 3 and an estimated required size is printed.

leniwkNone or int, optional

Note: if this argument is None then a default value will be used, determined as follows: $maxpts \times (14 + 5 \times maxlev) + 7 + 2$ .

The required value of $l e n i w k$ cannot be determined exactly in advance, but a suggested value is

l e n i w k = maxpts \times (14 + 5 \times m) + 7 \times m + 2,

where $maxpts$ is the expected maximum number of grid points at any one level and $m = o p t i [0]$ if $o p t i [0] > 0$ and $m = 3$ otherwise.

If during the execution the supplied value is found to be too small then the function returns with $e r r n o$ = 3 and an estimated required size is printed.

lenlwkNone or int, optional

Note: if this argument is None then a default value will be used, determined as follows: $maxpts + 1$ .

The required value of $l e n l w k$ cannot be determined exactly in advanced, but a suggested value is

l e n l w k = maxpts + 1,

where $maxpts$ is the expected maximum number of grid points at any one level.

If during the execution the supplied value is found to be too small then the function returns with $e r r n o$ = 3 and an estimated required size is printed.

dataarbitrary, optional

User-communication data for callback functions.

io_managerFileObjManager, optional

Manager for I/O in this routine.

spiked_sorderstr, optional

If $o p t r$ is spiked (i.e., has unit extent in all but one dimension, or has size $1$ ), $s p i k e d_s o r d e r$ selects the storage order to associate with it in the NAG Engine:

spiked_sorder = $'C'$: row-major storage will be used;
spiked_sorder = $'F'$: column-major storage will be used.

Two-dimensional arrays returned from callback functions in this routine must then use the same storage order.

Returns

tsfloat: The value of $t$ which has been reached. Normally $t s = t o u t$ .
dtfloat, ndarray, shape $(3)$: $d t [0]$ contains the time step size for the next time step. $d t [1]$ and $d t [2]$ are unchanged or set to their default values if zero on entry.
indint: $i n d = 1$ , if $i n d$ on input was $0$ or $1$ , or $i n d = 11$ , if $i n d$ on input was $10$ or $11$ .

Raises

NagValueError

(errno $1$ )

On entry, $i n d$ is not equal to $0$ or $1$ : $i n d = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $l e n l w k$ too small for initial grid level: $l e n l w k = ⟨ v a l u e ⟩$ , minimum value $= ⟨ v a l u e ⟩$ . Note that subsequent levels will require more. Consult document.

(errno $1$ )

On entry, $l e n i w k$ too small for initial grid level: $l e n i w k = ⟨ v a l u e ⟩$ , minimum value $= ⟨ v a l u e ⟩$ . Note that subsequent levels will require more. Consult document.

(errno $1$ )

On entry, $l e n r w k$ too small for initial grid level: $l e n r w k = ⟨ v a l u e ⟩$ , minimum value $= ⟨ v a l u e ⟩$ . Note that subsequent levels will require more. Consult document.

(errno $1$ )

On entry, $y m a x$ too close to $y m i n$ : $y m a x = ⟨ v a l u e ⟩$ and $y m i n = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $x m a x$ too close to $x m i n$ : $x m a x = ⟨ v a l u e ⟩$ and $x m i n = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $y m i n = ⟨ v a l u e ⟩$ and $y m a x = ⟨ v a l u e ⟩$ .

Constraint: $y m a x > y m i n$ .

(errno $1$ )

On entry, $x m i n = ⟨ v a l u e ⟩$ and $x m a x = ⟨ v a l u e ⟩$ .

Constraint: $x m a x > x m i n$ .

(errno $1$ )

On entry, $n y = ⟨ v a l u e ⟩$ .

Constraint: $n y \geq 4$ .

(errno $1$ )

On entry, $n x = ⟨ v a l u e ⟩$ .

Constraint: $n x \geq 4$ .

(errno $1$ )

On entry, $npde = ⟨ v a l u e ⟩$ .

Constraint: $npde \geq 1$ .

(errno $1$ )

On entry, $d t [0] = ⟨ v a l u e ⟩$ and $d t [2] = ⟨ v a l u e ⟩$ . Note that $d t [2]$ was reset to default if zero on entry.

Constraint: if $i n d = 0$ , $d t [0] \leq d t [2]$ .

(errno $1$ )

On entry, $d t [0] = ⟨ v a l u e ⟩$ and $d t [1] = ⟨ v a l u e ⟩$ . Note that $d t [1]$ was reset to default if zero on entry.

Constraint: if $i n d = 0$ , $d t [0] \geq d t [1]$ .

(errno $1$ )

On entry, $i n d = 0$ and $d t [0]$ too large: $d t [0] = ⟨ v a l u e ⟩$ and $maximum value = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $i n d = 0$ and $d t [0]$ too small: $d t [0] = ⟨ v a l u e ⟩$ and $minimum value = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $d t [0] = ⟨ v a l u e ⟩$ .

Constraint: if $i n d = 0$ , $d t [0] \geq 0.0$ .

(errno $1$ )

On entry, $d t [1] = ⟨ v a l u e ⟩$ and $d t [2] = ⟨ v a l u e ⟩$ .

Constraint: $d t [1] \leq d t [2]$ .

(errno $1$ )

On entry, $d t [2] = ⟨ v a l u e ⟩$ .

Constraint: $d t [2] \geq 0.0$ .

(errno $1$ )

On entry, $d t [1] = ⟨ v a l u e ⟩$ .

Constraint: $d t [1] \geq 0.0$ .

(errno $1$ )

On entry, $i = ⟨ v a l u e ⟩$ , $j = ⟨ v a l u e ⟩$ and $o p t r [i - 1, j - 1] = ⟨ v a l u e ⟩$ .

Constraint: $o p t r [i - 1, j - 1] \geq 0.0$ .

(errno $1$ )

On entry, $j = ⟨ v a l u e ⟩$ and $o p t r [0, j - 1] = ⟨ v a l u e ⟩$ .

Constraint: $o p t r [0, j - 1] > 0.0$ .

(errno $1$ )

On entry, $o p t i [0] = ⟨ v a l u e ⟩$ , $i = ⟨ v a l u e ⟩$ and $o p t i [i - 1] = ⟨ v a l u e ⟩$ .

Constraint: if $o p t i [0] > 0$ , $o p t i [i - 1] \geq 0$ .

(errno $1$ )

On entry, $o p t i [0] = ⟨ v a l u e ⟩$ .

Constraint: $o p t i [0] \geq 0$ .

(errno $1$ )

On entry, $t o l t = ⟨ v a l u e ⟩$ .

Constraint: $t o l t > 0.0$ .

(errno $1$ )

On entry, $t o l s = ⟨ v a l u e ⟩$ .

Constraint: $t o l s > 0.0$ .

(errno $1$ )

On entry, $t o u t - t s$ too small: $t o u t - t s = ⟨ v a l u e ⟩$ .

(errno $1$ )

On entry, $t o u t = ⟨ v a l u e ⟩$ and $t s = ⟨ v a l u e ⟩$ .

Constraint: $t o u t > t s$ .

(errno $2$ )

Attempted time-step smaller than specified minimum. Check problem formulation in $p d e d e f$ , $b n d a r y$ and $p d e i v$ . Try increasing $i t r a c e$ for more information.

(errno $3$ )

One or more of the workspace arrays are too small. Try increasing $i t r a c e$ for more information.

Warns

NagAlgorithmicWarning

(errno $4$ ): $I E R R$ set to $1$ in $m o n i t r$ . Integration completed as far as $t s$ : $t s = ⟨ v a l u e ⟩$ .
(errno $5$ ): Integration completed, but maximum number of levels too small for required accuracy.

Notes

No equivalent traditional C interface for this routine exists in the NAG Library.

dim2_gen_order2_rectangle integrates the system of PDEs:

F_{j} (t, x, y, u, u_{t}, u_{x}, u_{y}, u_{x x}, u_{x y}, u_{y y}) = 0, j = 1, 2, \dots, npde,

for $x$ and $y$ in the rectangular domain $x_{m i n} \leq x \leq x_{m a x}$ , $y_{m i n} \leq y \leq y_{m a x}$ , and time interval $t_{0} \leq t \leq t_{o u t}$ , where the vector $u$ is the set of solution values

u (x, y, t) = {[u_{1} (x, y, t), \dots, u_{npde} (x, y, t)]}^{T},

and $u_{t}$ denotes partial differentiation with respect to $t$ , and similarly for $u_{x}$ etc.

The functions $F_{j}$ must be supplied by you in $p d e d e f$ . Similarly the initial values of the functions $u (x, y, t)$ must be specified at $t = t_{0}$ in $p d e i v$ .

Note that whilst complete generality is offered by the master equations (1), dim2_gen_order2_rectangle is not appropriate for all PDEs. In particular, hyperbolic systems should not be solved using this function. Also, at least one component of $u_{t}$ must appear in the system of PDEs.

The boundary conditions must be supplied by you in $b n d a r y$ in the form

G_{j} (t, x, y, u, u_{t}, u_{x}, u_{y}) = 0,

for all $y$ when $x_{m i n}$ or $x_{m a x}$ and for all $x$ when $y = y_{m i n}$ or $y = y_{m a x}$ and $j = 1, 2, \dots, npde$

The domain is covered by a uniform coarse base grid of size $n_{x} \times n_{y}$ specified by you, and nested finer uniform subgrids are subsequently created in regions with high spatial activity. The refinement is controlled using a space monitor which is computed from the current solution and a user-supplied space tolerance $t o l s$ . A number of options, e.g., the maximum number of grid levels at any time, and some weighting factors, can be specified in the arrays $o p t i$ and $o p t r$ . Further details of the refinement strategy can be found in Further Comments.

The system of PDEs and the boundary conditions are discretized in space on each grid using a standard second-order finite difference scheme (centred on the internal domain and one-sided at the boundaries), and the resulting system of ODEs is integrated in time using a second-order, two-step, implicit BDF method with variable step size. The time integration is controlled using a time monitor computed at each grid level from the current solution and a user-supplied time tolerance $t o l t$ , and some further optional user-specified weighting factors held in $o p t r$ (see Further Comments for details). The time monitor is used to compute a new step size, subject to restrictions on the size of the change between steps, and (optional) user-specified maximum and minimum step sizes held in $d t$ . The step size is adjusted so that the remaining integration interval is an integer number times $Δ t$ . In this way a solution is obtained at $t = t_{o u t}$ .

A modified Newton method is used to solve the nonlinear equations arising from the time integration. You may specify (in $o p t i$ ) the maximum number of Newton iterations to be attempted. A Jacobian matrix is calculated at the beginning of each time step. If the Newton process diverges or the maximum number of iterations is exceeded, a new Jacobian is calculated using the most recent iterates and the Newton process is restarted. If convergence is not achieved after the (optional) user-specified maximum number of new Jacobian evaluations, the time step is retried with $Δ t = Δ t / 4$ . The linear systems arising from the Newton iteration are solved using a BI-CGSTAB iterative method, in combination with ILU preconditioning. The maximum number of iterations can be specified by you in $o p t i$ .

The solution at all grid levels is stored in the workspace arrays, along with other information needed for a restart (i.e., a continuation call). It is not intended that you extract the solution from these arrays, indeed the necessary information regarding these arrays is not included. The user-supplied monitor $m o n i t r$ should be used to obtain the solution at particular levels and times. $m o n i t r$ is called at the end of every time step, with the last step being identified via the input argument $t l a s t$ .

Within $p d e i v$ , $p d e d e f$ , $b n d a r y$ and $m o n i t r$ the data structure is as follows. Each point on a particular grid is given an index (ranging from $1$ to the total number of points on the grid) and all coordinate or solution information is stored in arrays according to this index, e.g., $x [i - 1]$ and $y [i - 1]$ contain the $x$ - and $y$ coordinate of point $i$ , and $u [i - 1, j - 1]$ contains the $j$ th solution component $u_{j}$ at point $i$ .

Further details of the underlying algorithm can be found in Further Comments and in Blom and Verwer (1993) and Blom et al. (1996) and the references therein.

References

Adjerid, S and Flaherty, J E, 1988, A local refinement finite element method for two-dimensional parabolic systems, SIAM J. Sci. Statist. Comput. (9), 792–811

Blom, J G, Trompert, R A and Verwer, J G, 1996, Algorithm 758. VLUGR2: A vectorizable adaptive grid solver for PDEs in 2D, Trans. Math. Software (22), 302–328

Blom, J G and Verwer, J G, 1993, VLUGR2: A vectorized local uniform grid refinement code for PDEs in 2D, Report NM-R9306, CWI, Amsterdam

Brown, P N, Hindmarsh, A C and Petzold, L R, 1994, Using Krylov methods in the solution of large scale differential-algebraic systems, SIAM J. Sci. Statist. Comput. (15), 1467–1488

Trompert, R A, 1993, Local uniform grid refinement and systems of coupled partial differential equations, Appl. Numer. Maths (12), 331–355

Trompert, R A and Verwer, J G, 1993, Analysis of the implicit Euler local uniform grid refinement method, SIAM J. Sci. Comput. (14), 259–278

NAG and Python

Return to Front

naginterfaces.library.pde.dim2_gen_order2_rectangle¶

naginterfaces.library.pde.dim2_​gen_​order2_​rectangle¶

naginterfaces.library.pde.dim2_gen_order2_rectangle¶