NAG Toolbox: nag_pde_2d_gen_order2_rectilinear (d03rb)

Purpose

Syntax

Description

Figure 1

Figure 2

Figure 3

References

Parameters

Compulsory Input Parameters

1:     $\mathrm{ts}$ – double scalar

The initial value of the independent variable $t$.

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

2:     $\mathrm{tout}$ – double scalar

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

3:     $\mathrm{dt}\left(3\right)$ – double array

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 \left(\mathbf{tout}-\mathbf{ts}\right)$ 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.

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(\left|\mathbf{ts}\right|,\left|\mathbf{tout}\right|\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)$.

4:     $\mathrm{tols}$ – double scalar

The space tolerance used in the grid refinement strategy ($\sigma$ in equation (4)). See Refinement Strategy.

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

5:     $\mathrm{tolt}$ – double scalar

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

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

6:     $\mathrm{inidom}$ – function handle or string containing name of m-file

inidom must specify the base grid in terms of the data structure described in Description. inidom is not referenced if, on entry, $\mathbf{ind}=1$. nag_pde_2d_gen_order2_checkgrid (d03ry) can be called from inidom to obtain a simple graphical representation of the base grid, and to verify the data that you have specified in inidom. nag_pde_2d_gen_order2_rectilinear (d03rb) also checks the validity of the data, but you are strongly advised to call nag_pde_2d_gen_order2_checkgrid (d03ry) to ensure that the base grid is exactly as required.

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$.

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

Input Parameters

1:     $\mathrm{maxpts}$ – int64int32nag_int scalar

The maximum number of base grid points allowed by the available workspace.

2:     $\mathrm{ierr}$ – int64int32nag_int scalar

Will be initialized by nag_pde_2d_gen_order2_rectilinear (d03rb) to some value prior to internal calls to inidom.

Output Parameters

1:     $\mathrm{xmin}$ – double scalar

2:     $\mathrm{xmax}$ – double scalar

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

3:     $\mathrm{ymin}$ – double scalar

4:     $\mathrm{ymax}$ – double scalar

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

5:     $\mathrm{nx}$ – int64int32nag_int scalar

6:     $\mathrm{ny}$ – int64int32nag_int scalar

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

7:     $\mathrm{npts}$ – int64int32nag_int scalar

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 $-1$ to avoid overwriting memory.

8:     $\mathrm{nrows}$ – int64int32nag_int scalar

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

9:     $\mathrm{nbnds}$ – int64int32nag_int scalar

The total number of physical boundaries and corners in the base grid.

10:   $\mathrm{nbpts}$ – int64int32nag_int scalar

The total number of boundary points in the base grid.

11:   $\mathrm{lrow}\left(:\right)$ – int64int32nag_int array

$\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}$.

12:   $\mathrm{irow}\left(:\right)$ – int64int32nag_int array

$\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}$.

13:   $\mathrm{icol}\left(:\right)$ – int64int32nag_int array

$\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}$.

14:   $\mathrm{llbnd}\left(:\right)$ – int64int32nag_int array

$\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.

15:   $\mathrm{ilbnd}\left(:\right)$ – int64int32nag_int array

$\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 Description.

16:   $\mathrm{lbnd}\left(:\right)$ – int64int32nag_int array

$\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.

17:   $\mathrm{ierr}$ – int64int32nag_int scalar

If the required number of grid points is larger than maxpts, ierr must be set to $-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.

7:     $\mathrm{pdedef}$ – function handle or string containing name of m-file

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.

[res] = pdedef(npts, npde, t, x, y, u, ut, ux, uy, uxx, uxy, uyy)

Input Parameters

1:     $\mathrm{npts}$ – int64int32nag_int scalar

The number of grid points in the current grid.

2:     $\mathrm{npde}$ – int64int32nag_int scalar

The number of PDEs in the system.

3:     $\mathrm{t}$ – double scalar

The current value of the independent variable $t$.

4:     $\mathrm{x}\left(\mathbf{npts}\right)$ – double array

$\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:     $\mathrm{y}\left(\mathbf{npts}\right)$ – double array

$\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:     $\mathrm{u}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{u}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{ut}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{ut}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{ux}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{ux}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{uy}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{uy}\left(\mathit{i},\mathit{j}\right)$ 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:   $\mathrm{uxx}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{uxx}\left(\mathit{i},\mathit{j}\right)$ 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:   $\mathrm{uxy}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{uxy}\left(\mathit{i},\mathit{j}\right)$ 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:   $\mathrm{uyy}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{uyy}\left(\mathit{i},\mathit{j}\right)$ 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}$.

Output Parameters

1:     $\mathrm{res}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{res}\left(\mathit{i},\mathit{j}\right)$ 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.

8:     $\mathrm{bndary}$ – function handle or string containing name of m-file

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 function.

[res] = bndary(npts, npde, t, x, y, u, ut, ux, uy, nbnds, nbpts, llbnd, ilbnd, lbnd, res)

Input Parameters

1:     $\mathrm{npts}$ – int64int32nag_int scalar

The number of grid points in the current grid.

2:     $\mathrm{npde}$ – int64int32nag_int scalar

The number of PDEs in the system.

3:     $\mathrm{t}$ – double scalar

The current value of the independent variable $t$.

4:     $\mathrm{x}\left(\mathbf{npts}\right)$ – double array

$\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:     $\mathrm{y}\left(\mathbf{npts}\right)$ – double array

$\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:     $\mathrm{u}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{u}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{ut}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{ut}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{ux}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{ux}\left(\mathit{i},\mathit{j}\right)$ 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:     $\mathrm{uy}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{uy}\left(\mathit{i},\mathit{j}\right)$ 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:   $\mathrm{nbnds}$ – int64int32nag_int scalar

The total number of physical boundaries and corners in the grid.

11:   $\mathrm{nbpts}$ – int64int32nag_int scalar

The total number of boundary points in the grid.

12:   $\mathrm{llbnd}\left(\mathbf{nbnds}\right)$ – int64int32nag_int array

$\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:   $\mathrm{ilbnd}\left(\mathbf{nbnds}\right)$ – int64int32nag_int array

$\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 Description.

14:   $\mathrm{lbnd}\left(\mathbf{nbpts}\right)$ – int64int32nag_int array

$\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}\left(\mathbf{lbnd}\left(\mathit{i}\right),\mathit{j}\right)$, for $\mathit{i}=1,2,\dots ,\mathbf{nbpts}$ and $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

15:   $\mathrm{res}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

Contains function values returned by pdedef.

Output Parameters

1:     $\mathrm{res}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{res}\left(\mathbf{lbnd}\left(\mathit{i}\right),\mathit{j}\right)$ 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.

9:     $\mathrm{pdeiv}$ – function handle or string containing name of m-file

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$.

[u] = pdeiv(npts, npde, t, x, y)

Input Parameters

1:     $\mathrm{npts}$ – int64int32nag_int scalar

The number of grid points in the base grid.

2:     $\mathrm{npde}$ – int64int32nag_int scalar

The number of PDEs in the system.

3:     $\mathrm{t}$ – double scalar

The (initial) value of the independent variable $t$.

4:     $\mathrm{x}\left(\mathbf{npts}\right)$ – double array

$\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:     $\mathrm{y}\left(\mathbf{npts}\right)$ – double array

$\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}$.

Output Parameters

1:     $\mathrm{u}\left(\mathbf{npts},\mathbf{npde}\right)$ – double array

$\mathbf{u}\left(\mathit{i},\mathit{j}\right)$ 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}$.

10:   $\mathrm{monitr}$ – function handle or string containing name of m-file

monitr is called by nag_pde_2d_gen_order2_rectilinear (d03rb) 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. nag_pde_2d_gen_order2_rectilinear_extractgrid (d03rz) should be called from monitr in order to extract the number of points and their $\left(x,y\right)$ 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.

[ierr] = monitr(npde, t, dt, dtnew, tlast, nlev, xmin, ymin, dxb, dyb, lgrid, istruc, lsol, sol, ierr)

Input Parameters

1:     $\mathrm{npde}$ – int64int32nag_int scalar

The number of PDEs in the system.

2:     $\mathrm{t}$ – double scalar

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

3:     $\mathrm{dt}$ – double scalar

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

4:     $\mathrm{dtnew}$ – double scalar

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

5:     $\mathrm{tlast}$ – logical scalar

Indicates if intermediate or final time step. $\mathbf{tlast}=\mathit{false}$ for an intermediate step, $\mathbf{tlast}=\mathit{true}$ for the last call to monitr before returning to your program.

6:     $\mathrm{nlev}$ – int64int32nag_int scalar

The number of grid levels used at time t.

7:     $\mathrm{xmin}$ – double scalar

8:     $\mathrm{ymin}$ – double scalar

The $\left(x,y\right)$ coordinates of the lower-left corner of the virtual grid.

9:     $\mathrm{dxb}$ – double scalar

10:   $\mathrm{dyb}$ – double scalar

The sizes of the base grid spacing in the $x$- and $y$-direction respectively.

11:   $\mathrm{lgrid}\left(:\right)$ – int64int32nag_int array

Contains pointers to the start of the grid structures in istruc, and must be passed unchanged to nag_pde_2d_gen_order2_rectilinear_extractgrid (d03rz) in order to extract the grid information.

12:   $\mathrm{istruc}\left(:\right)$ – int64int32nag_int array

Contains the grid structures for each grid level and must be passed unchanged to nag_pde_2d_gen_order2_rectilinear_extractgrid (d03rz) in order to extract the grid information.

13:   $\mathrm{lsol}\left(\mathbf{nlev}\right)$ – int64int32nag_int array

$\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:   $\mathrm{sol}\left(\mathit{lenrwk}-\left(6\times \mathbf{npde}+1\right)\right)$ – double array

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

$$\mathbf{u}\left(\mathit{i},\mathit{j}\right)=\mathbf{sol}\left(\mathbf{lsol}\left(\mathit{l}\right)+\left(\mathit{j}-1\right)\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 nag_pde_2d_gen_order2_rectilinear_extractgrid (d03rz)).

15:   $\mathrm{ierr}$ – int64int32nag_int scalar

Will be initialized by nag_pde_2d_gen_order2_rectilinear (d03rb) to some value prior to internal calls to ierr.

Output Parameters

1:     $\mathrm{ierr}$ – int64int32nag_int scalar

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.

11:   $\mathrm{opti}\left(4\right)$ – int64int32nag_int array

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$.

12:   $\mathrm{optr}\left(3,\mathbf{npde}\right)$ – double array

May be used to specify the optional vectors $u^{\max }$, $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$.

$\mathbf{optr}\left(1,\mathit{j}\right)$, 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}\left(1,\mathit{j}\right)>0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

$\mathbf{optr}\left(2,\mathit{j}\right)$, 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}\left(2,\mathit{j}\right)\ge 0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

$\mathbf{optr}\left(3,\mathit{j}\right)$, 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}\left(3,\mathit{j}\right)\ge 0.0$, for $\mathit{j}=1,2,\dots ,\mathbf{npde}$.

Constraints:

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

13:   $\mathrm{rwk}\left(\mathbf{lenrwk}\right)$ – double array

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

$$\mathbf{lenrwk}=\mathit{maxpts}\times \mathbf{npde}\times \left(5\times l+18\times \mathbf{npde}+9\right)+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 function returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see nag_file_set_unit_error (x04aa)).

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

14:   $\mathrm{iwk}\left(\mathbf{leniwk}\right)$ – int64int32nag_int array

If $\mathbf{ind}=0$, iwk need not be set. Otherwise iwk must remain unchanged from a previous call to nag_pde_2d_gen_order2_rectilinear (d03rb).

15:   $\mathrm{lenlwk}$ – int64int32nag_int scalar

The dimension of the array lwk.

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

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

16:   $\mathrm{itrace}$ – int64int32nag_int scalar

The level of trace information required from nag_pde_2d_gen_order2_rectilinear (d03rb). itrace may take the value $-1$, $0$, $1$, $2$ or $3$.

$\mathbf{itrace}=-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 nag_file_set_unit_advisory (x04ab)). This output contains details of the time integration, the nonlinear iteration and the linear solver.

If $\mathbf{itrace}<-1$, then $-1$ is assumed and similarly if $\mathbf{itrace}>3$, then $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.

17:   $\mathrm{ind}$ – int64int32nag_int scalar

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 function. In this case, only the following parameters may be reset between calls to nag_pde_2d_gen_order2_rectilinear (d03rb): tout, dt, tols, tolt, opti, optr, itrace and ifail. pdedef is assumed to be serial.

$\mathbf{ind}=10$

Equivalent to $\mathbf{ind}=0$. This option is included only for compatibility with other NAG library products.

$\mathbf{ind}=11$

Equivalent to $\mathbf{ind}=1$. This option is included only for compatibility with other NAG library products.

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

Optional Input Parameters

1:     $\mathrm{npde}$ – int64int32nag_int scalar

Default: the dimension of the array optr.

The number of PDEs in the system.

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

2:     $\mathrm{lenrwk}$ – int64int32nag_int scalar

Default: the dimension of the array rwk.

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

$$\mathbf{lenrwk}=\mathit{maxpts}\times \mathbf{npde}\times \left(5\times l+18\times \mathbf{npde}+9\right)+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 function returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see nag_file_set_unit_error (x04aa)).

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

3:     $\mathrm{leniwk}$ – int64int32nag_int scalar

Default: the dimension of the array iwk.

The dimension of the array iwk.

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

$$\mathbf{leniwk}=\mathit{maxpts}\times \left(14+5\times m\right)+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 function returns with $\mathbf{ifail}=\mathbf{3}$ and an estimated required size is printed on the current error message unit (see nag_file_set_unit_error (x04aa)).

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

Output Parameters

1:     $\mathrm{ts}$ – double scalar

The value of $t$ which has been reached. Normally $\mathbf{ts}=\mathbf{tout}$.

2:     $\mathrm{dt}\left(3\right)$ – double array

$\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.

3:     $\mathrm{rwk}\left(\mathbf{lenrwk}\right)$ – double array

Communication array, used to store information between calls to nag_pde_2d_gen_order2_rectilinear (d03rb).

4:     $\mathrm{iwk}\left(\mathbf{leniwk}\right)$ – int64int32nag_int array

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 nag_pde_2d_gen_order2_rectilinear (d03rb). If the specified maximum number of Newton or linear solver iterations is exceeded at any stage, then the maximums above are set to the specified maximum plus one.

5:     $\mathrm{ind}$ – int64int32nag_int scalar

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

6:     $\mathrm{ifail}$ – int64int32nag_int scalar

$\mathbf{ifail}=\mathbf{0}$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Cases prefixed with W are classified as warnings and do not generate an error of type NAG:error_n. See nag_issue_warnings.

   $\mathbf{ifail}=1$

On entry,	$\mathbf{npde}<1$,
or	$\mathbf{tout}\le \mathbf{ts}$,
or	tout is too close to ts,
or	$\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)<0.0$,
or	$\mathbf{dt}\left(i\right)<0.0$, for $\mathit{i}=2\text{ or }3$,
or	$\mathbf{dt}\left(2\right)>\mathbf{dt}\left(3\right)$,
or	$\mathbf{ind}=0$ and $0.0<\mathbf{dt}\left(1\right)<10\times \mathit{machine precision}\times \max \left(\left|\mathbf{ts}\right|,\left|\mathbf{tout}\right|\right)$,
or	$\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)>\mathbf{tout}-\mathbf{ts}$,
or	$\mathbf{ind}=0$ and $\mathbf{dt}\left(1\right)<\mathbf{dt}\left(2\right)\text{ or }\mathbf{dt}\left(1\right)>\mathbf{dt}\left(3\right)$,
or	tols or $\mathbf{tolt}\le 0.0$,
or	$\mathbf{opti}\left(1\right)<0$,
or	$\mathbf{opti}\left(1\right)>0$ and $\mathbf{opti}\left(j\right)<0$, for $\mathit{j}=2$, $3$ or $4$,
or	$\mathbf{optr}\left(1,j\right)\le 0.0$, for some $j=1,2,\dots ,\mathbf{npde}$,
or	$\mathbf{optr}\left(2,j\right)<0.0$, for some $j=1,2,\dots ,\mathbf{npde}$,
or	$\mathbf{optr}\left(3,j\right)<0.0$, for some $j=1,2,\dots ,\mathbf{npde}$,
or	$\mathbf{ind}\ne 0$ or $1$,
or	$\mathbf{ind}=1$ on initial entry to nag_pde_2d_gen_order2_rectilinear (d03rb).

   $\mathbf{ifail}=2$

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 is too small for the required number of grid points. At the initial time step this error may result because you set ierr to $-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.

W  $\mathbf{ifail}=4$

ierr was set to $1$ in monitr, forcing control to be passed back to calling program. Integration was successful as far as $\mathbf{t}=\mathbf{ts}$.

W  $\mathbf{ifail}=5$

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$

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.

   $\mathbf{ifail}=-399$

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

   $\mathbf{ifail}=-999$

Dynamic memory allocation failed.

Accuracy

Further Comments

Algorithm Outline

Refinement Strategy

Time Integration

Example

Open in the MATLAB editor: d03rb_example

function d03rb_example


fprintf('d03rb example results\n\n');

global iout xsol ysol usol vsol inds;

ts    = 0;
twant = [0.25; 1];
dt    = [0.001; 1e-07; 0];
tols  = 0.1;
tolt  = 0.05;
opti  = int64([5;0;0;0]);
optr = [1, 1; 1, 1; 1, 1];
rwk  = zeros(426000, 1);
iwk  = zeros(117037, 1, 'int64');
lenlwk = int64(6000);
itrace = int64(0);
ind  = int64(0);
inds  = int64(0);

for iout = 1:2
  tout = twant(iout);
  [ts, dt, rwk, iwk, ind, ifail] = ...
    d03rb(...
          ts, tout, dt, tols, tolt, @inidom, @pdedef, ...
          @bndary, @pdeiv, @monitr, opti, optr, ...
          rwk, iwk, lenlwk, itrace, ind);
  fprintf('\nStatistics\n');
  fprintf('Time = %8.4f\n', ts);
  fprintf('Total number of accepted timesteps = %d\n', iwk(1));
  fprintf('Total number of rejected timesteps = %d\n', iwk(2));
  fprintf('\n             T o t a l  n u m b e r  o f    \n');
  fprintf('          Residual  Jacobian    Newton  Lin sys\n');
  fprintf('             evals     evals     iters    iters\n');
  fprintf(' At level \n');
  maxlev = opti(1);
  for j = 1:maxlev
    if (iwk(j+2) ~= 0)
      fprintf('%6d %10d %10d %10d %10d\n', j, iwk(j+2), iwk(j+2+maxlev), ...
                                 iwk(j+2+2*maxlev), iwk(j+2+3*maxlev) );
    end
  end
  fprintf('\n             M a x i m u m  n u m b e r  o f\n');
  fprintf('              Newton iters    Lin sys iters \n');
  fprintf(' At level \n');
  for j = 1:maxlev
    if (iwk(j+2) ~= 0)
      fprintf('%6d%14d%14d\n', j, iwk(j+2+4*maxlev), iwk(j+2+5*maxlev) );
    end
  end
end

% Plot solutions u and v at t=1.0
fig1 =  figure;
scatter3(xsol,ysol,usol,15,vsol,'o','fill');
title('2D Burgers'' equation at t=1 on disjoint domain: u');
xlabel('x');
ylabel('y');
zlabel('u(x,y;t=1)');
fig2 =  figure;
scatter3(xsol,ysol,vsol,15,vsol,'o','fill');
view(-54,32);
xlabel('x');
ylabel('y');
zlabel('v(x,y;t=1)');
title('2D Burgers'' equation at t=1 on disjoint domain: v');


function [res] = bndary(npts, npde, t, x, y, u, ut, ux, uy, nbnds, ...
                        nbpts, llbnd, ilbnd, lbnd, res)

  epsilon = 1e-3;

  for k = llbnd(1):nbpts
    i = lbnd(k);
    a = (-4*x(i)+4*y(i)-t)/(32*epsilon);
    if (a <= 0)
      res(i,1) = u(i,1) - (0.75-0.25/(1+exp(a)));
      res(i,2) = u(i,2) - (0.75+0.25/(1+exp(a)));
    else
      res(i,1) = u(i,1) - (0.75-0.25*exp(-a)/(exp(-a)+1));
      res(i,2) = u(i,2) - (0.75+0.25*exp(-a)/(exp(-a)+1));
    end
  end
  

function [xmin, xmax, ymin, ymax, nx, ny, npts, nrows, nbnds, nbpts, ...
          lrow, irow, icol, llbnd, ilbnd, lbnd, ierr] = inidom(maxpts, ierr)

  nrows = int64(11);
  npts  = int64(105);
  nbnds = int64(28);
  nbpts = int64(72);

  lrow  = zeros(nrows, 1, 'int64');
  irow  = zeros(nrows, 1, 'int64');
  icol  = zeros(npts, 1, 'int64');
  llbnd = zeros(nbnds, 1, 'int64');
  ilbnd = zeros(nbnds, 1, 'int64');
  lbnd  = zeros(nbpts, 1, 'int64');



icold = int64([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]);

ilbndd = int64([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]);

irowd  = int64([0,1,2,3,4,5,6,7,8,9,10]);

lbndd  = int64([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]);

llbndd = int64([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]);

lrowd  = int64([1,4,15,26,37,46,57,68,79,88,97]);

nx = int64(11);
ny = int64(11);

% check maxpts against rough estimate of npts
  if (maxpts < nx*ny)
     ierr = -1;
     return;
  end

  xmin = 0;
  ymin = 0;
  xmax = 1;
  ymax = 1;

lrow(1:nrows)  = lrowd(1:nrows);
irow(1:nrows)  = irowd(1:nrows);
llbnd(1:nbnds) = llbndd(1:nbnds);
ilbnd(1:nbnds) = ilbndd(1:nbnds);
lbnd(1:nbpts)  = lbndd(1:nbpts);
icol(1:npts)   = icold(1:npts);

function [res] = pdedef(npts, npde, t, x, y, u, ut, ux, uy, uxx, uxy, uyy)
  res = zeros(npts, npde);

  epsilon = 1e-3;
  uxxyy = epsilon*(uxx(1:npts,1:2)+uyy(1:npts,1:2));
  uuxuy(1:npts,1) = -u(1:npts,1).*ux(1:npts,1)-u(1:npts,2).*uy(1:npts,1);
  uuxuy(1:npts,2) = -u(1:npts,1).*ux(1:npts,2)-u(1:npts,2).*uy(1:npts,2);
  res(1:npts,1:2) = ut(1:npts,1:2)-(uuxuy+uxxyy);

function [u] = pdeiv(npts, npde, t, x, y)
  u = zeros(npts, npde);

  epsilon = 1e-3;

  for i = 1:npts
    a = (-4*x(i)+4*y(i)-t)/(32*epsilon);
    if (a <= 0)
       u(i,1) = 0.75 - 0.25/(1+exp(a));
       u(i,2) = 0.75 + 0.25/(1+exp(a));
    else
       u(i,1) = 0.75 - 0.25*exp(-a)/(exp(-a)+1);
       u(i,2) = 0.75 + 0.25*exp(-a)/(exp(-a)+1);
    end
  end


function [ierr] = ...
    monitr(npde, t, dt, dtnew, tlast, nlev, xmin, ymin, dxb, dyb, lgrid, ...
                 istruc, lsol, sol, ierr)

  lenxy=int64(2500);

  global iout xsol ysol usol vsol inds;

  if (tlast && iout == 2)
    for level = int64(1:nlev)
      ipsol = lsol(level);

      % Get grid information
      [npts, x, y, ifail] = ...
         d03rz(...
               level, xmin, ymin, dxb, dyb, lgrid, istruc, lenxy);
      % Get exact solution
      [uex] = pdeiv(npts, npde, t, x, y);

      xsol(inds+1:inds+npts) = x(1:npts);
      ysol(inds+1:inds+npts) = y(1:npts);
      usol(inds+1:inds+npts) = sol(ipsol+1:ipsol+npts);
      vsol(inds+1:inds+npts) = sol(ipsol+npts+1:ipsol+npts+npts);
      inds = inds + npts;
    end
  end

d03rb example results


Statistics
Time =   0.2500
Total number of accepted timesteps = 14
Total number of rejected timesteps = 0

             T o t a l  n u m b e r  o f    
          Residual  Jacobian    Newton  Lin sys
             evals     evals     iters    iters
 At level 
     1        196         14         28         14
     2        196         14         28         22
     3        196         14         28         25
     4        196         14         28         31
     5        141         10         21         29

             M a x i m u m  n u m b e r  o f
              Newton iters    Lin sys iters 
 At level 
     1             2             1
     2             2             1
     3             2             1
     4             2             2
     5             3             2

Statistics
Time =   1.0000
Total number of accepted timesteps = 45
Total number of rejected timesteps = 0

             T o t a l  n u m b e r  o f    
          Residual  Jacobian    Newton  Lin sys
             evals     evals     iters    iters
 At level 
     1        630         45         90         45
     2        630         45         90         78
     3        630         45         90         87
     4        630         45         90        124
     5        575         41         83        122

             M a x i m u m  n u m b e r  o f
              Newton iters    Lin sys iters 
 At level 
     1             2             1
     2             2             1
     3             2             1
     4             2             2
     5             3             2