NAG FL Interface
d03rbf (dim2_​gen_​order2_​rectilinear)

1 Purpose

2 Specification

3 Description

Figure 1

Figure 2

Figure 3

nrows = 11
npts = 105
nbnds = 28
nbpts = 72

lrow = (1,4,15,26,37,46,57,68,79,88,97)

irow = (0,1,2,3,4,5,6,7,8,9,10)

icol = (0,1,2,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,8,9,10,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,6,7,8,9,10,
        0,1,2,3,4,5,6,7,8,
        0,1,2,3,4,5,6,7,8,
        0,1,2,3,4,5,6,7,8)

lbnd = (2,
        4,15,26,37,46,57,68,79,88,
        98,99,100,101,102,103,104,
        96,
        86,85,84,83,82,
        70,59,48,39,28,17,6,
        8,9,10,11,12,13,
        18,29,40,49,60,
        72,73,74,75,76,77,
        67,56,45,36,25,
        33,32,
        42,
        52,53,
        43,
        1,97,105,87,81,3,7,71,78,14,31,51,54,34)

llbnd = (1,2,11,18,19,24,31,37,42,48,53,55,56,58,59,60,
         61,62,63,64,65,66,67,68,69,70,71,72)

ilbnd = (1,2,3,4,1,4,1,2,3,4,3,4,1,2,12,23,34,41,14,41,
         12,23,34,41,43,14,21,32)

4 References

5 Arguments

1: $\mathbf{npde}$ – Integer Input

On entry: the number of PDEs in the system.

Constraint: $\mathbf{npde}\ge 1$.

2: $\mathbf{ts}$ – Real (Kind=nag_wp) Input/Output

On entry: the initial value of the independent variable $t$.

On exit: the value of $t$ which has been reached. Normally $\mathbf{ts}=\mathbf{tout}$.

Constraint: $\mathbf{ts}<\mathbf{tout}$.

3: $\mathbf{tout}$ – Real (Kind=nag_wp) Input

On entry: the final value of $t$ to which the integration is to be carried out.

4: $\mathbf{dt}\left(3\right)$ – Real (Kind=nag_wp) array Input/Output

On entry: the initial, minimum and maximum time step sizes respectively.

$\mathbf{dt}\left(1\right)$

Specifies the initial time step size to be used on the first entry, i.e., when $\mathbf{ind}=0$. If $\mathbf{dt}\left(1\right)=0.0$ then the default value $\mathbf{dt}\left(1\right)=0.01\times (\mathbf{tout}-\mathbf{ts})$ is used. On subsequent entries ($\mathbf{ind}=1$), the value of $\mathbf{dt}\left(1\right)$ is not referenced.

$\mathbf{dt}\left(2\right)$

Specifies the minimum time step size to be attempted by the integrator. If $\mathbf{dt}\left(2\right)=0.0$ the default value $\mathbf{dt}\left(2\right)=10.0\times \mathit{machine precision}$ is used.

$\mathbf{dt}\left(3\right)$

Specifies the maximum time step size to be attempted by the integrator. If $\mathbf{dt}\left(3\right)=0.0$ the default value $\mathbf{dt}\left(3\right)=\mathbf{tout}-\mathbf{ts}$ is used.

On exit: $\mathbf{dt}\left(1\right)$ contains the time step size for the next time step. $\mathbf{dt}\left(2\right)$ and $\mathbf{dt}\left(3\right)$ are unchanged or set to their default values if zero on entry.

Constraints:

• if $\mathbf{ind}=0$, $\mathbf{dt}\left(1\right)\ge 0.0$;
• if $\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)>0.0$, $10.0\times \mathit{machine precision}\times \max (\left|\mathbf{ts}\right|,\left|\mathbf{tout}\right|)\le \mathbf{dt}\left(1\right)\le \mathbf{tout}-\mathbf{ts}$ and $\mathbf{dt}\left(2\right)\le \mathbf{dt}\left(1\right)\le \mathbf{dt}\left(3\right)$, where the values of $\mathbf{dt}\left(2\right)$ and $\mathbf{dt}\left(3\right)$ will have been reset to their default values if zero on entry;
• $0\le \mathbf{dt}\left(2\right)\le \mathbf{dt}\left(3\right)$.

5: $\mathbf{tols}$ – Real (Kind=nag_wp) Input

On entry: the space tolerance used in the grid refinement strategy ($\sigma$ in equation (4)). See Section 9.2.

Constraint: $\mathbf{tols}>0.0$.

6: $\mathbf{tolt}$ – Real (Kind=nag_wp) Input

On entry: the time tolerance used to determine the time step size ($\tau$ in equation (7)). See Section 9.3.

Constraint: $\mathbf{tolt}>0.0$.

7: $\mathbf{inidom}$ – Subroutine, supplied by the user. External Procedure

inidom must specify the base grid in terms of the data structure described in Section 3. inidom is not referenced if, on entry, $\mathbf{ind}=1$.

Note: the boundaries of the base grid should consist of as many points as are necessary to employ second-order space discretization, i.e., a boundary enclosing the internal part of the domain must include at least $3$ grid points including the corners. If Neumann boundary conditions are to be applied the minimum is $4$.

The specification of inidom is:

Fortran Interface copy

Subroutine inidom ( maxpts, xmin, xmax, ymin, ymax, nx, ny, npts, nrows, nbnds, nbpts, lrow, irow, icol, llbnd, ilbnd, lbnd, ierr) Integer, Intent (In) :: maxpts Integer, Intent (Inout) :: lrow(*), irow(*), icol(*), llbnd(*), ilbnd(*), lbnd(*), ierr Integer, Intent (Out) :: nx, ny, npts, nrows, nbnds, nbpts Real (Kind=nag_wp), Intent (Out) :: xmin, xmax, ymin, ymax

C Header Interface copy

void  inidom (const Integer *maxpts, double *xmin, double *xmax, double *ymin, double *ymax, Integer *nx, Integer *ny, Integer *npts, Integer *nrows, Integer *nbnds, Integer *nbpts, Integer lrow[], Integer irow[], Integer icol[], Integer llbnd[], Integer ilbnd[], Integer lbnd[], Integer *ierr)

C++ Header Interface copy

#include <nag.h> extern "C" { void  inidom (const Integer &maxpts, double &xmin, double &xmax, double &ymin, double &ymax, Integer &nx, Integer &ny, Integer &npts, Integer &nrows, Integer &nbnds, Integer &nbpts, Integer lrow[], Integer irow[], Integer icol[], Integer llbnd[], Integer ilbnd[], Integer lbnd[], Integer &ierr) }

1: $\mathbf{maxpts}$ – Integer Input

On entry: the maximum number of base grid points allowed by the available workspace.

2: $\mathbf{xmin}$ – Real (Kind=nag_wp) Output

3: $\mathbf{xmax}$ – Real (Kind=nag_wp) Output

On exit: the extents of the virtual grid in the $x$-direction, i.e., the $x$ coordinates of the left and right boundaries respectively.

Constraint: $\mathbf{xmin}<\mathbf{xmax}$ and xmax must be sufficiently distinguishable from xmin for the precision of the machine being used.

4: $\mathbf{ymin}$ – Real (Kind=nag_wp) Output

5: $\mathbf{ymax}$ – Real (Kind=nag_wp) Output

On exit: the extents of the virtual grid in the $y$-direction, i.e., the $y$ coordinates of the left and right boundaries respectively.

Constraint: $\mathbf{ymin}<\mathbf{ymax}$ and ymax must be sufficiently distinguishable from ymin for the precision of the machine being used.

6: $\mathbf{nx}$ – Integer Output

7: $\mathbf{ny}$ – Integer Output

On exit: the number of virtual grid points in the $x$- and $y$-direction respectively (including the boundary points).

Constraint: nx and $\mathbf{ny}\ge 4$.

8: $\mathbf{npts}$ – Integer Output

On exit: the total number of points in the base grid. If the required number of points is greater than maxpts then inidom must be exited immediately with ierr set to $\mathrm{-1}$ to avoid overwriting memory.

Constraint: $\mathbf{npts}\le \mathbf{nx}\times \mathbf{ny}$ and if $\mathbf{ierr}\ne \mathrm{-1}$ on exit, $\mathbf{npts}\le \mathbf{maxpts}$.

9: $\mathbf{nrows}$ – Integer Output

On exit: the total number of rows of the virtual grid that contain base grid points. This is the maximum base row index.

Constraint: $4\le \mathbf{nrows}\le \mathbf{ny}$.

10: $\mathbf{nbnds}$ – Integer Output

On exit: the total number of physical boundaries and corners in the base grid.

Constraint: $\mathbf{nbnds}\ge 8$.

11: $\mathbf{nbpts}$ – Integer Output

On exit: the total number of boundary points in the base grid.

Constraint: $12\le \mathbf{nbpts}<\mathbf{npts}$.

12: $\mathbf{lrow}\left(*\right)$ – Integer array Output

On exit: $\mathbf{lrow}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nrows}$, must contain the base grid index of the first grid point in base grid row $\mathit{i}$.

Constraints:

• $1\le \mathbf{lrow}\left(\mathit{i}\right)\le \mathbf{npts}$, for $\mathit{i}=1,2,\dots ,\mathbf{nrows}$;
• $\mathbf{lrow}\left(\mathit{i}-1\right)<\mathbf{lrow}\left(\mathit{i}\right)$, for $\mathit{i}=2,3,\dots ,\mathbf{nrows}$.

13: $\mathbf{irow}\left(*\right)$ – Integer array Output

On exit: $\mathbf{irow}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nrows}$, must contain the virtual row number $v_y$ that corresponds to base grid row $\mathit{i}$.

Constraints:

• $0\le \mathbf{irow}\left(\mathit{i}\right)\le \mathbf{ny}$, for $\mathit{i}=1,2,\dots ,\mathbf{nrows}$;
• $\mathbf{irow}\left(\mathit{i}-1\right)<\mathbf{irow}\left(\mathit{i}\right)$, for $\mathit{i}=2,3,\dots ,\mathbf{nrows}$.

14: $\mathbf{icol}\left(*\right)$ – Integer array Output

On exit: $\mathbf{icol}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$, must contain the virtual column number $v_x$ that contains base grid point $\mathit{i}$.

Constraint: $0\le \mathbf{icol}\left(\mathit{i}\right)\le \mathbf{nx}$, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

15: $\mathbf{llbnd}\left(*\right)$ – Integer array Output

On exit: $\mathbf{llbnd}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$, must contain the element of lbnd corresponding to the start of the $\mathit{i}$th boundary or corner.

Note: the order of the boundaries and corners in llbnd must be first all the boundaries and then all the corners. The end points of a boundary (i.e., the adjacent corner points) must not be included in the list of points on that boundary. Also, if a corner is shared by two pairs of physical boundaries then it has two types and must, therefore, be treated as two corners.

Constraints:

• $1\le \mathbf{llbnd}\left(\mathit{i}\right)\le \mathbf{nbpts}$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$;
• $\mathbf{llbnd}\left(\mathit{i}-1\right)<\mathbf{llbnd}\left(\mathit{i}\right)$, for $\mathit{i}=2,3,\dots ,\mathbf{nbnds}$.

16: $\mathbf{ilbnd}\left(*\right)$ – Integer array Output

On exit: $\mathbf{ilbnd}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$, must contain the type of the $\mathit{i}$th boundary (or corner), as given in Section 3.

Constraint: $\mathbf{ilbnd}\left(\mathit{i}\right)$ must be equal to one of the following: $1$, $2$, $3$, $4$, $12$, $23$, $34$, $41$, $21$, $32$, $43$ or $14$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$.

17: $\mathbf{lbnd}\left(*\right)$ – Integer array Output

On exit: $\mathbf{lbnd}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbpts}$, must contain the grid index of the $\mathit{i}$th boundary point. The order of the boundaries is as specified in llbnd, but within this restriction the order of the points in lbnd is arbitrary.

Constraint: $1\le \mathbf{lbnd}\left(\mathit{i}\right)\le \mathbf{npts}$, for $\mathit{i}=1,2,\dots ,\mathbf{nbpts}$.

18: $\mathbf{ierr}$ – Integer Input/Output

On entry: will be initialized by d03rbf to some value prior to internal calls to inidom.

On exit: if the required number of grid points is larger than maxpts, ierr must be set to $\mathrm{-1}$ to force a termination of the integration and an immediate return to the calling program with $\mathbf{ifail}=\mathbf{3}$. Otherwise, ierr should remain unchanged.

inidom must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d03rbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: inidom should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d03rbf. If your code inadvertently does return any NaNs or infinities, d03rbf is likely to produce unexpected results.

8: $\mathbf{pdedef}$ – Subroutine, supplied by the user. External Procedure

pdedef must evaluate the functions $F_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, 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 bndary. pdedef is called for each subgrid in turn.

The specification of pdedef is:

Fortran Interface copy

Subroutine pdedef ( npts, npde, t, x, y, u, ut, ux, uy, uxx, uxy, uyy, res) Integer, Intent (In) :: npts, npde Real (Kind=nag_wp), Intent (In) :: t, x(npts), y(npts), u(npts,npde), ut(npts,npde), ux(npts,npde), uy(npts,npde), uxx(npts,npde), uxy(npts,npde), uyy(npts,npde) Real (Kind=nag_wp), Intent (Out) :: res(npts,npde)

C Header Interface copy

void  pdedef (const Integer *npts, const Integer *npde, const double *t, const double x[], const double y[], const double u[], const double ut[], const double ux[], const double uy[], const double uxx[], const double uxy[], const double uyy[], double res[])

C++ Header Interface copy

#include <nag.h> extern "C" { void  pdedef (const Integer &npts, const Integer &npde, const double &t, const double x[], const double y[], const double u[], const double ut[], const double ux[], const double uy[], const double uxx[], const double uxy[], const double uyy[], double res[]) }

1: $\mathbf{npts}$ – Integer Input

On entry: the number of grid points in the current grid.

2: $\mathbf{npde}$ – Integer Input

On entry: the number of PDEs in the system.

3: $\mathbf{t}$ – Real (Kind=nag_wp) Input

On entry: the current value of the independent variable $t$.

4: $\mathbf{x}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{x}\left(\mathit{i}\right)$ contains the $x$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

5: $\mathbf{y}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{y}\left(\mathit{i}\right)$ contains the $y$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

6: $\mathbf{u}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{u}(\mathit{i},\mathit{j})$ contains the value of the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

7: $\mathbf{ut}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{ut}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial t}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

8: $\mathbf{ux}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{ux}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial x}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

9: $\mathbf{uy}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{uy}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial y}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

10: $\mathbf{uxx}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{uxx}(\mathit{i},\mathit{j})$ contains the value of $\frac{{\partial }^{2}u}{\partial x^2}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

11: $\mathbf{uxy}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{uxy}(\mathit{i},\mathit{j})$ contains the value of $\frac{{\partial }^{2}u}{\partial x\partial y}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

12: $\mathbf{uyy}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{uyy}(\mathit{i},\mathit{j})$ contains the value of $\frac{{\partial }^{2}u}{\partial y^2}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

13: $\mathbf{res}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Output

On exit: $\mathbf{res}(\mathit{i},\mathit{j})$ must contain the value of $F_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$, although the residuals at boundary points will be ignored (and overwritten later on) and so they need not be specified here.

pdedef must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d03rbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: pdedef should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d03rbf. If your code inadvertently does return any NaNs or infinities, d03rbf is likely to produce unexpected results.

9: $\mathbf{bndary}$ – Subroutine, supplied by the user. External Procedure

bndary must evaluate the functions $G_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, 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 subroutine.

The specification of bndary is:

Fortran Interface copy

Subroutine bndary ( npts, npde, t, x, y, u, ut, ux, uy, nbnds, nbpts, llbnd, ilbnd, lbnd, res) Integer, Intent (In) :: npts, npde, nbnds, nbpts, llbnd(nbnds), ilbnd(nbnds), lbnd(nbpts) Real (Kind=nag_wp), Intent (In) :: t, x(npts), y(npts), u(npts,npde), ut(npts,npde), ux(npts,npde), uy(npts,npde) Real (Kind=nag_wp), Intent (Inout) :: res(npts,npde)

C Header Interface copy

void  bndary (const Integer *npts, const Integer *npde, const double *t, const double x[], const double y[], const double u[], const double ut[], const double ux[], const double uy[], const Integer *nbnds, const Integer *nbpts, const Integer llbnd[], const Integer ilbnd[], const Integer lbnd[], double res[])

C++ Header Interface copy

#include <nag.h> extern "C" { void  bndary (const Integer &npts, const Integer &npde, const double &t, const double x[], const double y[], const double u[], const double ut[], const double ux[], const double uy[], const Integer &nbnds, const Integer &nbpts, const Integer llbnd[], const Integer ilbnd[], const Integer lbnd[], double res[]) }

1: $\mathbf{npts}$ – Integer Input

On entry: the number of grid points in the current grid.

2: $\mathbf{npde}$ – Integer Input

On entry: the number of PDEs in the system.

3: $\mathbf{t}$ – Real (Kind=nag_wp) Input

On entry: the current value of the independent variable $t$.

4: $\mathbf{x}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{x}\left(\mathit{i}\right)$ contains the $x$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

5: $\mathbf{y}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{y}\left(\mathit{i}\right)$ contains the $y$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

6: $\mathbf{u}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{u}(\mathit{i},\mathit{j})$ contains the value of the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

7: $\mathbf{ut}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{ut}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial t}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

8: $\mathbf{ux}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{ux}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial x}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

9: $\mathbf{uy}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{uy}(\mathit{i},\mathit{j})$ contains the value of $\frac{\partial u}{\partial y}$ for the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

10: $\mathbf{nbnds}$ – Integer Input

On entry: the total number of physical boundaries and corners in the grid.

11: $\mathbf{nbpts}$ – Integer Input

On entry: the total number of boundary points in the grid.

12: $\mathbf{llbnd}\left(\mathbf{nbnds}\right)$ – Integer array Input

On entry: $\mathbf{llbnd}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$, contains the element of lbnd corresponding to the start of the $\mathit{i}$th boundary (or corner).

13: $\mathbf{ilbnd}\left(\mathbf{nbnds}\right)$ – Integer array Input

On entry: $\mathbf{ilbnd}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbnds}$, contains the type of the $\mathit{i}$th boundary, as given in Section 3.

14: $\mathbf{lbnd}\left(\mathbf{nbpts}\right)$ – Integer array Input

On entry: $\mathbf{lbnd}\left(\mathit{i}\right)$, contains the grid index of the $\mathit{i}$th boundary point, where the order of the boundaries is as specified in llbnd. Hence the $\mathit{i}$th boundary point has coordinates $\mathbf{x}\left(\mathbf{lbnd}\left(\mathit{i}\right)\right)$ and $\mathbf{y}\left(\mathbf{lbnd}\left(\mathit{i}\right)\right)$, and the corresponding solution values are $\mathbf{u}(\mathbf{lbnd}\left(\mathit{i}\right),\mathit{j})$, for $\mathit{i}=1,2,\dots ,\mathbf{nbpts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

15: $\mathbf{res}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Input/Output

On entry: contains function values returned by pdedef.

On exit: $\mathbf{res}(\mathbf{lbnd}\left(\mathit{i}\right),\mathit{j})$ must contain the value of $G_{\mathit{j}}$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, at the $\mathit{i}$th boundary point, for $\mathit{i}=1,2,\dots ,\mathbf{nbpts}$.

Note: elements of res corresponding to interior points, i.e., points not included in lbnd, must not be altered.

bndary must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d03rbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: bndary should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d03rbf. If your code inadvertently does return any NaNs or infinities, d03rbf is likely to produce unexpected results.

10: $\mathbf{pdeiv}$ – Subroutine, supplied by the user. External Procedure

pdeiv must specify the initial values of the PDE components $u$ at all points in the base grid. pdeiv is not referenced if, on entry, $\mathbf{ind}=1$.

The specification of pdeiv is:

Fortran Interface copy

Subroutine pdeiv ( npts, npde, t, x, y, u) Integer, Intent (In) :: npts, npde Real (Kind=nag_wp), Intent (In) :: t, x(npts), y(npts) Real (Kind=nag_wp), Intent (Out) :: u(npts,npde)

C Header Interface copy

void  pdeiv (const Integer *npts, const Integer *npde, const double *t, const double x[], const double y[], double u[])

C++ Header Interface copy

#include <nag.h> extern "C" { void  pdeiv (const Integer &npts, const Integer &npde, const double &t, const double x[], const double y[], double u[]) }

1: $\mathbf{npts}$ – Integer Input

On entry: the number of grid points in the base grid.

2: $\mathbf{npde}$ – Integer Input

On entry: the number of PDEs in the system.

3: $\mathbf{t}$ – Real (Kind=nag_wp) Input

On entry: the (initial) value of the independent variable $t$.

4: $\mathbf{x}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{x}\left(\mathit{i}\right)$ contains the $x$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

5: $\mathbf{y}\left(\mathbf{npts}\right)$ – Real (Kind=nag_wp) array Input

On entry: $\mathbf{y}\left(\mathit{i}\right)$ contains the $y$ coordinate of the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$.

6: $\mathbf{u}(\mathbf{npts},\mathbf{npde})$ – Real (Kind=nag_wp) array Output

On exit: $\mathbf{u}(\mathit{i},\mathit{j})$ must contain the value of the $\mathit{j}$th PDE component at the $\mathit{i}$th grid point, for $\mathit{i}=1,2,\dots ,\mathbf{npts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

pdeiv must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d03rbf is called. Arguments denoted as Input must not be changed by this procedure.

Note: pdeiv should not return floating-point NaN (Not a Number) or infinity values, since these are not handled by d03rbf. If your code inadvertently does return any NaNs or infinities, d03rbf is likely to produce unexpected results.

11: $\mathbf{monitr}$ – Subroutine, supplied by the user. External Procedure

monitr is called by d03rbf 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 tlast.

The input arguments contain information about the grid and solution at all grid levels used. d03rzf should be called from monitr in order to extract the number of points and their $(x,y)$ coordinates on a particular grid.

monitr can also be used to force an immediate tidy termination of the solution process and return to the calling program.

The specification of monitr is:

Fortran Interface copy

Subroutine monitr ( npde, t, dt, dtnew, tlast, nlev, xmin, ymin, dxb, dyb, lgrid, istruc, lsol, sol, ierr) Integer, Intent (In) :: npde, nlev, lgrid(*), istruc(*), lsol(nlev) Integer, Intent (Inout) :: ierr Real (Kind=nag_wp), Intent (In) :: t, dt, dtnew, xmin, ymin, dxb, dyb, sol(*) Logical, Intent (In) :: tlast

C Header Interface copy

void  monitr (const Integer *npde, const double *t, const double *dt, const double *dtnew, const logical *tlast, const Integer *nlev, const double *xmin, const double *ymin, const double *dxb, const double *dyb, const Integer lgrid[], const Integer istruc[], const Integer lsol[], const double sol[], Integer *ierr)

C++ Header Interface copy

#include <nag.h> extern "C" { void  monitr (const Integer &npde, const double &t, const double &dt, const double &dtnew, const logical &tlast, const Integer &nlev, const double &xmin, const double &ymin, const double &dxb, const double &dyb, const Integer lgrid[], const Integer istruc[], const Integer lsol[], const double sol[], Integer &ierr) }

1: $\mathbf{npde}$ – Integer Input

On entry: the number of PDEs in the system.

2: $\mathbf{t}$ – Real (Kind=nag_wp) Input

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

3: $\mathbf{dt}$ – Real (Kind=nag_wp) Input

On entry: the current time step size $\Delta t$, i.e., the time step size used for the integration step just completed.

4: $\mathbf{dtnew}$ – Real (Kind=nag_wp) Input

On entry: the time step size that will be used for the next time step.

5: $\mathbf{tlast}$ – Logical Input

On entry: indicates if intermediate or final time step. $\mathbf{tlast}=\mathrm{.FALSE.}$ for an intermediate step, $\mathbf{tlast}=\mathrm{.TRUE.}$ for the last call to monitr before returning to your program.

6: $\mathbf{nlev}$ – Integer Input

On entry: the number of grid levels used at time t.

7: $\mathbf{xmin}$ – Real (Kind=nag_wp) Input

8: $\mathbf{ymin}$ – Real (Kind=nag_wp) Input

On entry: the $(x,y)$ coordinates of the lower-left corner of the virtual grid.

9: $\mathbf{dxb}$ – Real (Kind=nag_wp) Input

10: $\mathbf{dyb}$ – Real (Kind=nag_wp) Input

On entry: the sizes of the base grid spacing in the $x$- and $y$-direction respectively.

11: $\mathbf{lgrid}\left(*\right)$ – Integer array Input

On entry: contains pointers to the start of the grid structures in istruc, and must be passed unchanged to d03rzf in order to extract the grid information.

12: $\mathbf{istruc}\left(*\right)$ – Integer array Input

On entry: contains the grid structures for each grid level and must be passed unchanged to d03rzf in order to extract the grid information.

13: $\mathbf{lsol}\left(\mathbf{nlev}\right)$ – Integer array Input

On entry: $\mathbf{lsol}\left(l\right)$ contains the pointer to the solution in sol at grid level $l$ and time t. ($\mathbf{lsol}\left(l\right)$ actually contains the array index immediately preceding the start of the solution in sol.)

14: $\mathbf{sol}\left(*\right)$ – Real (Kind=nag_wp) array Input

On entry: contains the solution $u$ at time t for each grid level $l$ in turn, positioned according to lsol. More precisely

$$\mathbf{u}(\mathit{i},\mathit{j})=\mathbf{sol}\left(\mathbf{lsol}\left(\mathit{l}\right)+(\mathit{j}-1)\times n_{\mathit{l}}+\mathit{i}\right)$$

represents the $\mathit{j}$th component of the solution at the $\mathit{i}$th grid point in the $\mathit{l}$th level, for $\mathit{i}=1,2,\dots ,n_{\mathit{l}}$, $\mathit{j}=1,2,\dots ,\mathbf{npde}$ and $\mathit{l}=1,2,\dots ,\mathbf{nlev}$, where $n_{\mathit{l}}$ is the number of grid points at level $\mathit{l}$ (obtainable by a call to d03rzf).

15: $\mathbf{ierr}$ – Integer Input/Output

On entry: will be initialized by d03rbf to some value prior to internal calls to ierr.

On exit: should be set to $1$ to force a termination of the integration and an immediate return to the calling program with $\mathbf{ifail}=\mathbf{4}$. ierr should remain unchanged otherwise.

monitr must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d03rbf is called. Arguments denoted as Input must not be changed by this procedure.

12: $\mathbf{opti}\left(4\right)$ – Integer array Input

On entry: may be set to control various options available in the integrator.

$\mathbf{opti}\left(1\right)=0$

All the default options are employed.

$\mathbf{opti}\left(1\right)>0$

The default value of $\mathbf{opti}\left(\mathit{i}\right)$, for $\mathit{i}=2,3,4$, can be obtained by setting $\mathbf{opti}\left(\mathit{i}\right)=0$.

$\mathbf{opti}\left(1\right)$

Specifies the maximum number of grid levels allowed (including the base grid). $\mathbf{opti}\left(1\right)\ge 0$. The default value is $\mathbf{opti}\left(1\right)=3$.

$\mathbf{opti}\left(2\right)$

Specifies the maximum number of Jacobian evaluations allowed during each nonlinear equations solution. $\mathbf{opti}\left(2\right)\ge 0$. The default value is $\mathbf{opti}\left(2\right)=2$.

$\mathbf{opti}\left(3\right)$

Specifies the maximum number of Newton iterations in each nonlinear equations solution. $\mathbf{opti}\left(3\right)\ge 0$. The default value is $\mathbf{opti}\left(3\right)=10$.

$\mathbf{opti}\left(4\right)$

Specifies the maximum number of iterations in each linear equations solution. $\mathbf{opti}\left(4\right)\ge 0$. The default value is $\mathbf{opti}\left(4\right)=100$.

Constraint: $\mathbf{opti}\left(1\right)\ge 0$ and if $\mathbf{opti}\left(1\right)>0$, $\mathbf{opti}\left(\mathit{i}\right)\ge 0$, for $\mathit{i}=2,3,4$.

13: $\mathbf{optr}(3,\mathbf{npde})$ – Real (Kind=nag_wp) array Input

On entry: may be used to specify the optional vectors $u^{\max }$, $w^s$ and $w^t$ in the space and time monitors (see Section 9).

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

$\mathbf{optr}(1,\mathit{j})$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, specifies $u_{\mathit{j}}^{\max }$, the approximate maximum absolute value of the $\mathit{j}$th component of $u$, as used in (4) and (7). $\mathbf{optr}(1,\mathit{j})>0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

$\mathbf{optr}(2,\mathit{j})$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, specifies $w_{\mathit{j}}^s$, the weighting factors used in the space monitor (see (4)) to indicate the relative importance of the $\mathit{j}$th component of $u$ on the space monitor. $\mathbf{optr}(2,\mathit{j})\ge 0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

$\mathbf{optr}(3,\mathit{j})$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$, specifies $w_{\mathit{j}}^t$, the weighting factors used in the time monitor (see (6)) to indicate the relative importance of the $\mathit{j}$th component of $u$ on the time monitor. $\mathbf{optr}(3,\mathit{j})\ge 0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

Constraints:

• $\mathbf{optr}(1,\mathit{j})>0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$;
• $\mathbf{optr}(\mathit{i},\mathit{j})\ge 0.0$, for $\mathit{i}=2,3$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

14: $\mathbf{rwk}\left(\mathbf{lenrwk}\right)$ – Real (Kind=nag_wp) array Communication Array

15: $\mathbf{lenrwk}$ – Integer Input

On entry: the dimension of the array rwk as declared in the (sub)program from which d03rbf is called.

The required value of lenrwk cannot be determined exactly in advance, but a suggested value is

$$\mathbf{lenrwk}=\mathit{maxpts}\times \mathbf{npde}\times (5\times l+18\times \mathbf{npde}+9)+2\times \mathit{maxpts}\text{,}$$

where $l=\mathbf{opti}\left(1\right)$ if $\mathbf{opti}\left(1\right)\ne 0$ and $l=3$ otherwise, and $\mathit{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 routine returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see x04aaf).

Note: the size of lenrwk cannot be checked upon initial entry to d03rbf since the number of grid points on the base grid is not known.

16: $\mathbf{iwk}\left(\mathbf{leniwk}\right)$ – Integer array Communication Array

On entry: if $\mathbf{ind}=0$, iwk need not be set. Otherwise iwk must remain unchanged from a previous call to d03rbf.

On exit: the following components of the array iwk concern the efficiency of the integration. Here, $m$ is the maximum number of grid levels allowed ($m=\mathbf{opti}\left(1\right)$ if $\mathbf{opti}\left(1\right)>1$ and $m=3$ otherwise), and $l$ is a grid level taking the values $l=1,2,\dots ,\mathit{nl}$, where $\mathit{nl}$ is the number of levels used.

$\mathbf{iwk}\left(1\right)$

Contains the number of steps taken in time.

$\mathbf{iwk}\left(2\right)$

Contains the number of rejected time steps.

$\mathbf{iwk}\left(2+l\right)$

Contains the total number of residual evaluations performed (i.e., the number of times pdedef was called) at grid level $l$.

$\mathbf{iwk}\left(2+m+l\right)$

Contains the total number of Jacobian evaluations performed at grid level $l$.

$\mathbf{iwk}\left(2+2\times m+l\right)$

Contains the total number of Newton iterations performed at grid level $l$.

$\mathbf{iwk}\left(2+3\times m+l\right)$

Contains the total number of linear solver iterations performed at grid level $l$.

$\mathbf{iwk}\left(2+4\times m+l\right)$

Contains the maximum number of Newton iterations performed at any one time step at grid level $l$.

$\mathbf{iwk}\left(2+5\times m+l\right)$

Contains the maximum number of linear solver iterations performed at any one time step at grid level $l$.

Note: the total and maximum numbers are cumulative over all calls to d03rbf. If the specified maximum number of Newton or linear solver iterations is exceeded at any stage, the maximums above are set to the specified maximum plus one.

17: $\mathbf{leniwk}$ – Integer Input

On entry: the dimension of the array iwk as declared in the (sub)program from which d03rbf is called.

The required value of leniwk cannot be determined exactly in advance, but a suggested value is

$$\mathbf{leniwk}=\mathit{maxpts}\times (14+5\times m)+7\times m+2\text{,}$$

where $\mathit{maxpts}$ is the expected maximum number of grid points at any one level and $m=\mathbf{opti}\left(1\right)$ if $\mathbf{opti}\left(1\right)>0$ and $m=3$ otherwise. If during the execution the supplied value is found to be too small then the routine returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see x04aaf).

Note: the size of leniwk cannot be checked upon initial entry to d03rbf since the number of grid points on the base grid is not known.

18: $\mathbf{lwk}\left(\mathbf{lenlwk}\right)$ – Logical array Workspace

19: $\mathbf{lenlwk}$ – Integer Input

On entry: the dimension of the array lwk as declared in the (sub)program from which d03rbf is called.

The required value of lenlwk cannot be determined exactly in advance, but a suggested value is

$$\mathbf{lenlwk}=\mathit{maxpts}+1\text{,}$$

where $\mathit{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 routine returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see x04aaf).

Note: the size of lenlwk cannot be checked upon initial entry to d03rbf since the number of grid points on the base grid is not known.

20: $\mathbf{itrace}$ – Integer Input

On entry: the level of trace information required from d03rbf. itrace may take the value $\mathrm{-1}$, $0$, $1$, $2$ or $3$.

$\mathbf{itrace}=\mathrm{-1}$

No output is generated.

$\mathbf{itrace}=0$

Only warning messages are printed.

$\mathbf{itrace}>0$

Output from the underlying solver is printed on the current advisory message unit (see x04abf). This output contains details of the time integration, the nonlinear iteration and the linear solver.

If $\mathbf{itrace}<\mathrm{-1}$, $\mathrm{-1}$ is assumed and similarly if $\mathbf{itrace}>3$, $3$ is assumed.

The advisory messages are given in greater detail as itrace increases. Setting $\mathbf{itrace}=1$ allows you to monitor the progress of the integration without possibly excessive information.

21: $\mathbf{ind}$ – Integer Input/Output

On entry: must be set to $0$ or $1$, alternatively $10$ or $11$.

$\mathbf{ind}=0$

Starts the integration in time. pdedef is assumed to be serial.

$\mathbf{ind}=1$

Continues the integration after an earlier exit from the routine. In this case, only the following parameters may be reset between calls to d03rbf: tout, dt, tols, tolt, opti, optr, itrace and ifail. pdedef is assumed to be serial.

$\mathbf{ind}=10$

Starts the integration in time. pdedef is assumed to have been parallelized by you, as described in Section 8. In all other respects, this is equivalent to $\mathbf{ind}=0$.

$\mathbf{ind}=11$

Continues the integration after an earlier exit from the routine. In this case, only the following parameters may be reset between calls to d03raf: tout, dt, tols, tolt, opti, optr, itrace and ifail. pdedef is assumed to have been parallelized by you, as described in Section 8. In all other respects, this is equivalent to $\mathbf{ind}=1$.

Constraint: $0\le \mathbf{ind}\le 1$ or $10\le \mathbf{ind}\le 11$.

On exit: $\mathbf{ind}=1$, if ind on input was $0$ or $1$, or $\mathbf{ind}=11$, if ind on input was $10$ or $11$.

Note: for users of serial versions of the NAG Library, it is recommended that you only use $\mathbf{ind}=0$ or $1$. See Section 8 for more information on the use of ind.

22: $\mathbf{ifail}$ – Integer Input/Output

On entry: ifail must be set to $0$, $\mathrm{-1}$ or $1$ to set behaviour on detection of an error; these values have no effect when no error is detected.

A value of $0$ causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of $\mathrm{-1}$ means that an error message is printed while a value of $1$ means that it is not.

If halting is not appropriate, the value $\mathrm{-1}$ or $1$ is recommended. If message printing is undesirable, then the value $1$ is recommended. Otherwise, the value $0$ is recommended. When the value $-\mathbf{1}$ or $\mathbf{1}$ is used it is essential to test the value of ifail on exit.

On exit: $\mathbf{ifail}=\mathbf{0}$ unless the routine detects an error or a warning has been flagged (see Section 6).

6 Error Indicators and Warnings

$\mathbf{ifail}=1$

On entry, $\mathbf{dt}\left(1\right)=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{ind}=0$, $\mathbf{dt}\left(1\right)\ge 0.0$.

On entry, $\mathbf{dt}\left(1\right)=⟨\mathit{\text{value}}⟩$ and $\mathbf{dt}\left(2\right)=⟨\mathit{\text{value}}⟩$. Note that $\mathbf{dt}\left(2\right)$ was reset to default if zero on entry.
Constraint: if $\mathbf{ind}=0$, $\mathbf{dt}\left(1\right)\ge \mathbf{dt}\left(2\right)$.

On entry, $\mathbf{dt}\left(1\right)=⟨\mathit{\text{value}}⟩$ and $\mathbf{dt}\left(3\right)=⟨\mathit{\text{value}}⟩$. Note that $\mathbf{dt}\left(3\right)$ was reset to default if zero on entry.
Constraint: if $\mathbf{ind}=0$, $\mathbf{dt}\left(1\right)\le \mathbf{dt}\left(3\right)$.

On entry, $\mathbf{dt}\left(2\right)=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{dt}\left(2\right)\ge 0.0$.

On entry, $\mathbf{dt}\left(2\right)=⟨\mathit{\text{value}}⟩$ and $\mathbf{dt}\left(3\right)=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{dt}\left(2\right)\le \mathbf{dt}\left(3\right)$.

On entry, $\mathbf{dt}\left(3\right)=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{dt}\left(3\right)\ge 0.0$.

On entry, $\mathit{i}=⟨\mathit{\text{value}}⟩$, $\mathit{j}=⟨\mathit{\text{value}}⟩$ and $\mathbf{optr}(\mathit{i},\mathit{j})=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{optr}(\mathit{i},\mathit{j})\ge 0.0$.

On entry, $\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)$ too large: $\mathbf{dt}\left(1\right)=⟨\mathit{\text{value}}⟩$ and $\text{maximum value}=⟨\mathit{\text{value}}⟩$.

On entry, $\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)$ too small: $\mathbf{dt}\left(1\right)=⟨\mathit{\text{value}}⟩$ and $\text{minimum value}=⟨\mathit{\text{value}}⟩$.

On entry, ind is not equal to $0$ or $1$: $\mathbf{ind}=⟨\mathit{\text{value}}⟩$.

On entry, $\mathit{j}=⟨\mathit{\text{value}}⟩$ and $\mathbf{optr}(1,\mathit{j})=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{optr}(1,\mathit{j})>0.0$.

On entry, $\mathbf{npde}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{npde}\ge 1$.

On entry, $\mathbf{opti}\left(1\right)=⟨\mathit{\text{value}}⟩$, $\mathit{i}=⟨\mathit{\text{value}}⟩$ and $\mathbf{opti}\left(\mathit{i}\right)=⟨\mathit{\text{value}}⟩$.
Constraint: if $\mathbf{opti}\left(1\right)>0$, $\mathbf{opti}\left(\mathit{i}\right)\ge 0$.

On entry, $\mathbf{opti}\left(1\right)=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{opti}\left(1\right)\ge 0$.

On entry, $\mathbf{tols}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{tols}>0.0$.

On entry, $\mathbf{tolt}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{tolt}>0.0$.

On entry, $\mathbf{tout}=⟨\mathit{\text{value}}⟩$ and $\mathbf{ts}=⟨\mathit{\text{value}}⟩$.
Constraint: $\mathbf{tout}>\mathbf{ts}$.

On entry, $\mathbf{tout}-\mathbf{ts}$ too small: $\mathbf{tout}-\mathbf{ts}=⟨\mathit{\text{value}}⟩$.

$\mathbf{ifail}=2$

Attempted time-step smaller than specified minimum. Check problem formulation in pdedef, bndary and pdeiv. Try increasing itrace for more information.

The time step size to be attempted is less than the specified minimum size. This may occur following time step failures and subsequent step size reductions caused by one or more of the following:

• the requested accuracy could not be achieved, i.e., tolt is too small,
• the maximum number of linear solver iterations, Newton iterations or Jacobian evaluations is too small,
• ILU decomposition of the Jacobian matrix could not be performed, possibly due to singularity of the Jacobian.

Setting itrace to a higher value may provide further information.

In the latter two cases you are advised to check their problem formulation in pdedef and/or bndary, and the initial values in pdeiv if appropriate.

$\mathbf{ifail}=3$

One or more of the workspace arrays are too small. Try increasing itrace for more information.

One or more of the workspace arrays is too small for the required number of grid points. At the initial time step this error may result because you set ierr to $\mathrm{-1}$ in inidom or the internal check on the number of grid points following the call to inidom. An estimate of the required sizes for the current stage is output, but more space may be required at a later stage.

$\mathbf{ifail}=4$

$\mathrm{IERR}$ set to $1$ in monitr. Integration completed as far as ts: $\mathbf{ts}=⟨\mathit{\text{value}}⟩$.

$\mathbf{ifail}=5$

Integration completed, but maximum number of levels too small for required accuracy.

The integration has been completed but the maximum number of levels specified in $\mathbf{opti}\left(1\right)$ was insufficient at one or more time steps, meaning that the requested space accuracy could not be achieved. To avoid this warning either increase the value of $\mathbf{opti}\left(1\right)$ or decrease the value of tols.

$\mathbf{ifail}=6$

Invalid output argument from inidom.

One or more of the output arguments of inidom was incorrectly specified, i.e.,

	$\mathbf{xmin}\ge \mathbf{xmax}$,
or	xmax too close to xmin,
or	$\mathbf{ymin}\ge \mathbf{ymax}$,
or	ymax too close to ymin,
or	nx or $\mathbf{ny}<4$,
or	$\mathbf{nrows}<4$,
or	$\mathbf{nrows}>\mathbf{ny}$,
or	$\mathbf{npts}>\mathbf{nx}\times \mathbf{ny}$,
or	$\mathbf{nbnds}<8$,
or	$\mathbf{nbpts}<12$,
or	$\mathbf{nbpts}\ge \mathbf{npts}$,
or	$\mathbf{lrow}\left(i\right)<1$ or $\mathbf{lrow}\left(i\right)>\mathbf{npts}$, for some $i=1,2,\dots ,\mathbf{nrows}$,
or	$\mathbf{lrow}\left(i\right)\le \mathbf{lrow}\left(i-1\right)$, for some $i=2,3,\dots ,\mathbf{nrows}$,
or	$\mathbf{irow}\left(i\right)<0$ or $\mathbf{irow}\left(i\right)>\mathbf{ny}$, for some $i=1,2,\dots ,\mathbf{nrows}$,
or	$\mathbf{irow}\left(i\right)\le \mathbf{irow}\left(i-1\right)$, for some $i=2,3,\dots ,\mathbf{nrows}$,
or	$\mathbf{icol}\left(i\right)<0$ or $\mathbf{icol}\left(i\right)>\mathbf{nx}$, for some $i=1,2,\dots ,\mathbf{npts}$,
or	$\mathbf{llbnd}\left(i\right)<1$ or $\mathbf{llbnd}\left(i\right)>\mathbf{nbpts}$, for some $i=1,2,\dots ,\mathbf{nbnds}$,
or	$\mathbf{llbnd}\left(i\right)\le \mathbf{llbnd}\left(i-1\right)$, for some $i=2,3,\dots ,\mathbf{nbnds}$,
or	$\mathbf{ilbnd}\left(i\right)\ne 1$, $2$, $3$, $4$, $12$, $23$, $34$, $41$, $21$, $32$, $43$ or $14$, for some $i=1,2,\dots ,\mathbf{nbnds}$,
or	$\mathbf{lbnd}\left(i\right)<1$ or $\mathbf{lbnd}\left(i\right)>\mathbf{npts}$, for some $i=1,2,\dots ,\mathbf{nbpts}$.

$\mathbf{ifail}=-99$

An unexpected error has been triggered by this routine. Please contact NAG.

See Section 7 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-399$

Your licence key may have expired or may not have been installed correctly.

See Section 8 in the Introduction to the NAG Library FL Interface for further information.

$\mathbf{ifail}=-999$

Dynamic memory allocation failed.

See Section 9 in the Introduction to the NAG Library FL Interface for further information.

7 Accuracy

8 Parallelism and Performance

res(1:npts,1:npde) = ut(1:npts,1:npde) - diffusion*(uxx(1:npts,1:         &
  npde)+uyy(1:npts,1:npde)) - damkohler*(one+heat_release-u(1:npts,       &
  1:npde))*exp(-activ_energy/u(1:npts,1:npde))

!$OMP DO
   Do i = 1, npts
      res(i,1:npde) = ut(i,1:npde) -diffusion*(uxx(i,1:npde)+uyy(i,1:npde &
       )) - damkohler*(1.0E0_nag_wp+heat_release-u(i,1:npde))*exp(-       &
        activ_energy/u(i,1:npde))
   End Do
!$OMP END DO

9 Further Comments

9.1 Algorithm Outline

9.2 Refinement Strategy

9.3 Time Integration