## MathPDE: A Package to Solve PDEs by Finite Differences NB   CDF   PDF

A package for solving time-dependent partial differential equations (PDEs), MathPDE, is presented. It implements finite-difference methods. After making a sequence of symbolic transformations on the PDE and its initial and boundary conditions, MathPDE automatically generates a problem-specific set of Mathematica functions to solve the numerical problem, which is essentially a system of algebraic equations. MathPDE then internally calls MathCode, a Mathematica-to-C++ code generator, to generate a C++ program for solving the algebraic problem, and compiles it into an executable that can be run via MathLink. When the algebraic system is nonlinear, the Newton-Raphson method is used and SuperLU, a library for sparse systems, is used for matrix operations. This article discusses the wide range of PDEs that can be handled by MathPDE, the accuracy of the finite-difference schemes used, and importantly, the ability to handle both regular and irregular spatial domains. Since a standalone C++ program is generated to compute the numerical solution, the package offers portability.

### 1. Introduction

Mathematical problems described by partial differential equations (PDEs) are ubiquitous in science and engineering. Examples range from the simple (but very common) diffusion equation, through the wave and Laplace equations, to the nonlinear equations of fluid mechanics, elasticity, and chaos theory. However, few PDEs have closed-form analytical solutions, making numerical methods necessary. The numerical task is made difficult by the dimensionality and geometry of the independent variables, the nonlinearities in the system, sensitivity to boundary conditions, a lack of formal understanding of the kind of solution method to be employed for a particular problem, and so on.

A number of methods have been developed to deal with the numerical solution of PDEs. These fall into two broad categories: the finite-difference methods and the finite-element methods. Roughly speaking, both transform a PDE problem to the problem of solving a system of coupled algebraic equations. In finite-difference methods, the domain of the independent variables is approximated by a discrete set of points called a grid, and the dependent variables are defined only at these points. Any derivative then automatically acquires the meaning of a certain kind of difference between dependent variable values at the grid points. This identification helps us transform the PDE problem to a system of coupled algebraic equations. In the finite-element method, the dependent variable is approximated by an interpolation polynomial. The domain is subdivided into a set of non-overlapping regions that completely cover it; each such region is called a finite element. The interpolation polynomial is determined by a set of coefficients in each element; the small size of the elements generally ensures that a low-degree polynomial is sufficient. A weighted residual method is then used to set up a system of algebraic equations for these coefficients. The numerical problem in both methods therefore is one of solving a system of algebraic equations.

In this article, we present the Mathematica package MathPDE that implements the finite-difference method for time-dependent PDE problems. We give examples of the way in which symbolic programming lends a degree of generality to MathPDE. Before doing so, we would like to put our work in perspective. We first review, very briefly, the extant PDE packages that we are familiar with that have been developed over the years.

Mathematica has a built-in function NDSolve that can numerically solve a variety of PDEs and offers the user a very simple and quick route to solving PDEs numerically. So a natural question that arises is why another solver is needed. In this regard, we emphasize two points. First, MathPDE is able to handle irregular spatial domains, not just rectangular or cubic domains. Second, MathPDE can produce a standalone executable that runs independently of Mathematica, providing portability.

The following systems use either a compiled language directly, or have a high-level interface language that preprocesses the input and employs subroutines in a compiled language. None of them uses symbolic programming.

Diffpack (see [1]) presents an object-oriented problem-solving environment for the numerical solution of PDEs. It implements finite-difference as well as finite-element methods and provides C++ modules with a wide selection of interchangeable and application-independent components. ELLPACK (see [2]) presents a high-level interface language for formulating elliptic PDE problems and presents more than 50 problem-solving modules for handling complex elliptic boundary value problems. It is implemented as a FORTRAN preprocessor and can handle a variety of system geometries in two dimensions (both finite differences and finite elements) and rectangular geometries in three dimensions (finite differences only). Cogito and COMPOSE were developed at Uppsala University, Sweden (see [3, 4]). Both implement finite-difference schemes for time-dependent problems and exploit object-oriented technology to develop a new kind of software library with parts that can be flexibly combined, enhancing easy construction and modification of programs. Cogito is a high-performance solver that comprises the three layers Parallel, Grid, and Solver, the lower two layers being Fortran 90 parallel code, while the Solver is written in C++. COMPOSE is a C++ object-oriented system that exploits Overture [5] for grid generation.

The work on numerical PDE libraries is far too extensive for us to be able to present an exhaustive review here (see [6, 7, 8, 9] for overviews). We would like to emphasize that while MathPDE has the generality to handle a wide range of PDE problems, it is not useful, at least in its present form, for certain problems where very specialized finite-difference decoupling schemes are known to work much better than the straightforward finite differencing that our approach uses. The Navier-Stokes equation is one such example (see [4] for an approach to this problem). In general, the work discussed in this paper is not adequate for problems where specialized numerical libraries have been known to perform effectively. Instead, it is suitable for PDE problems that are often encountered in engineering modeling situations. Even for such problems, several static subroutine libraries have been developed that perform efficiently, as discussed above. On the other hand, MathPDE can treat a wide range of spatial domains (see Section 3). There is also the great potential to combine the enormous benefits of the interactive Mathematica environment with its large library of built-in mathematical functions, which enables the user to experiment with a large class of PDE problems. Finally, MathPDE generates C++ source code and a standalone executable, addressing the important issue of portability.

Our preliminary results were reported in the references [10, 11, and 12]. We now give a brief summary of the present paper. MathPDE accepts the PDE and the initial and boundary conditions, along with the geometry of the system, in Mathematica’s list format. It supports geometries of fairly general shapes and dimensions. The symbolic engine applies explicit and implicit difference methods and discretizes the geometry to a grid. MathPDE then generates a program for solving the numerical problem, which is essentially an algebraic equation system on the grid; if the system is nonlinear, then a multidimensional Newton-Raphson method [7] is used to solve it. This program makes use of the external library SuperLU to efficiently handle sparse linear algebraic systems [13]. MathPDE internally calls MathCode [14] to translate the numerical program into C++ and then to generate an executable. All these operations are done by invoking a single function (SetupMathPDE) provided by MathPDE. The executable can then be run either from within Mathematica or externally to obtain the numerical solution of the PDE problem.

Here is an outline of this article. In Section 2, we provide a quick introduction to MathPDE with the example of a one-dimensional diffusion equation.

We discuss the ideas behind the package in Section 3. Section 3.1 is about the numerical algorithms used, such as the discretization of derivatives, the solution of an algebraic system, and Fourier stability. In Section 3.2, we discuss how the spatial domain is discretized. Section 3.3 discusses code generation and its translation into C++ using MathCode.

In Section 4, we discuss application examples that illustrate the strengths and limitations of MathPDE. The examples chosen are divided into problems in one, two, and three dimensions, and there is a section on two nonlinear problems.

In Section 5, we give a summary of our work and make some concluding remarks.

### 2. A Quick Tour of MathPDE

In this section we provide a brief tour of MathPDE, taking the example of a one-dimensional diffusion equation. We illustrate how to define the PDE problem, set up the numerical problem using MathPDE, and generate C++ code using MathCode. The package MathPDE is loaded in the usual way.

#### 2.1 Problem Definition

Let us solve the one-dimensional diffusion equation

with Dirichlet conditions

at the boundaries of the domain

and the initial condition

The problem is defined as a list.

The list has two elements: the first element defines the PDE, the boundary conditions, and finally the initial condition, each as a list, and the second element defines the spatial domain as an iterator.

#### 2.2 Setup

Once the problem is defined, the following command sets up the numerical code.

In this case, the last argument of SetupMathPDE is empty because there are no parameters in the input problem. If there were parameters, they could be specified in this list. After completing the symbolic part, the command loads MathCode, which then generates C++ code and compiles it. In the present problem, the C++ code is a set of 13 functions in addition to the main() function. The executable is also installed by MathCode, so that we can run it from the notebook interface.

#### 2.3 Numerical Computation

We can now execute the function SolvePDE to obtain a numerical solution.

We can extract the solution computed by this command by invoking solutionAt and we can plot it.

We can uninstall the C++ program and delete all the files related to MathCode if we do not need them.

We must quit the kernel before trying a new problem.

### 3. Design of MathPDE

#### 3.1 Numerical Algorithms

##### 3.1.1 Choosing an Appropriate Finite-Difference Method

In the finite-difference method, the independent variables are regarded as discrete and the domain becomes a grid. The derivatives of the dependent variables then automatically become differences between values at a combination of these grid points; the actual combination depends on the nature of the difference approximation. After such an approximation is performed, no derivatives are left and only the functions are evaluated at the grid points; the resulting system of relations between the values of dependent variables at a set of neighboring grid points is referred to as the stencil for the PDE system. Applying the stencil at all the grid points results in a system of coupled algebraic equations. In time-dependent problems, to which the present work is addressed, the solution at any time (which is discretized as well) is determined, in general, from the solution up to the previous time instant ; the solution values at each grid point at the time instant are the unknowns in the algebraic system.

Depending on the kind of discretization used, we may be able to explicitly solve for each unknown from one of the algebraic equations. In such a case, the difference scheme is called explicit. In cases where we cannot do this explicitly, we refer to the difference scheme as implicit.

Let us illustrate this with the example of the one-dimensional diffusion equation that we solved in Section 2. Suppose we replace by a first-degree forward approximation, , and by a second-degree central approximation, , where and are the step sizes along and . The result is the difference equation

that can be easily solved for to get

so we have an explicit finite-difference method. A simple but important observation is that the right-hand side of the above equation involves dependent variable values at time that are already known, so we can use the right-hand side to recursively compute the dependent variable at any grid point and at any time, given the initial and boundary conditions. On the other hand, if we replace by a second-degree central approximation, at time , rather than at time , then we get a difference equation

that cannot be solved for the dependent variable in terms of . In this case, we have an implicit finite-difference method, since the spatial derivative is advanced to the highest time . In this case, since we have a linear system, we can state the problem in terms of matrices, and typically we have to solve a matrix problem of the kind . Nonlinear systems have to be handled differently; see Section 3.1.5.

In the symbolic part, MathPDE first extracts the list of all the derivatives of dependent variables with respect to independent variables from the equations specified by the user. This is straightforward using symbolic programming. Then an important decision to make is to choose the finite-difference approximation (FDA) to use for each derivative. This is based on the following simple algorithm.

Suppose we have to choose an FDA degree for the derivative with respect to of . We look for all the derivatives of with respect to in the given PDE, and find the highest order, ; we use as the approximation degree for all derivatives of with respect to , no matter what order. The same procedure works for derivatives with respect to other independent variables. The next thing to decide is which discretization to choose among the possible choices for the FDA (see Section 3.1.2). We choose a central-difference approximation scheme for derivatives with respect to spatial variables and a forward scheme for time derivatives. Implicit schemes can be obtained by advancing spatial derivatives. It is easy to see that this algorithm leads to the approximation schemes discussed above for the diffusion equation. MathPDE generates both explicit and implicit schemes, and the choice between them is made at run time based on considerations of numerical stability (see Section 3.1.3).

For boundary conditions, we choose a forward or a backward scheme, depending on whether the condition applies at the left or the right boundary.

It is possible for the user to intervene and force a different scheme (see Section 3.1.4).

##### 3.1.2 Discretization of the Derivatives: Fornberg Algorithm

Once a choice has been made for the approximation degree for a derivative, we must obtain its finite-difference approximation. A straightforward way to do this is to use the Lagrange interpolation formula (see any text on numerical analysis, for example [7]). However, an elegant algorithm due to Fornberg is particularly suitable for implementation in Mathematica [15]. We have used his very simple code to discretize a derivative.

Now, if we want a second-degree () central approximation () to a second-order () derivative, we must use this.

This gives us the coefficients in the resulting stencil (compare with the coefficients on the right-hand side of equation (2)). A MathPDE function based on the above function can then be used to obtain the FDA of any derivative. The following gives the second-degree () central approximation () to a second-order () derivative.

This gives the first-degree forward approximation to a first-order time derivative; here h and k are the step sizes in x and t, respectively. Mixed derivatives can be easily handled with recursive calls to , as done by the MathPDE function that discretizes equations involving derivatives, as illustrated by the discretization of the following PDE.

The second argument to the function , , specifies the FDA to use for each derivative that appears in the PDE. It contains the two integers degree and kind to be passed as arguments to for each derivative. Thus, the first argument of x means that the FDA must be second degree, central, for the first x derivative of u; the second argument of x specifies the integers required to approximate the second derivative of u with respect to x, and so on.

##### 3.1.3 Fourier Stability

MathPDE performs a Fourier stability test (see [6] for example) for simple explicit methods when the PDE problem is linear. To understand the underlying ideas, consider again the one-dimensional diffusion equation (3). If we use an explicit method described in Section 3.1.1, we get the stencil (equation (2)):

To understand the behavior of the solution obtained by using this difference equation in the limit as , let us assume the solution for is like a plane wave:

where and are the wave vector and frequency of the plane wave. We then obtain from equation (5),

For the solution to be stable, it is necessary that the absolute value of the right-hand side of equation (7) is less than unity, or equivalently,

From the inequality on the left, we get Since the smallest value of is , we get

as the criterion for the difference equation (5) to have a stable solution.

Based on this kind of analysis, MathPDE provides a function that returns the stability criterion for simple PDEs like diffusion and wave equations. This is used to help eliminate computational procedures that could be unstable when the step sizes chosen violate the criterion; in such cases, MathPDE selects an appropriate implicit scheme.

##### 3.1.4 Higher-Degree Approximation

Finite-difference approximation of a derivative leads to truncation errors because the approximation is based on truncating the series expansion of a function to a certain number of terms determined by the approximation degree. To get a smaller truncation error, we can specify a higher-degree finite-difference approximation. We illustrate this with a simple example. Suppose we would like to solve the one-dimensional diffusion equation by using fourth-degree spatial discretization. The following sets up this problem.

There is an important issue that arises in the case of a higher-degree FDA. Let us consider a fourth-degree central approximation of a spatial derivative.

Note that this is a five-point scheme: it involves the grid points , , x, , and . Now suppose x varies from 1 to N on a grid. When , which is immediately next to the boundary , the above stencil would involve the point outside the grid. Therefore we use a second-degree FDA for the point , with the fourth-degree FDA taking over from onward. A similar device is used to eliminate the point at the other end. In general, the number of layers near the boundary where a lower-degree FDA is used depends on the degree of FDA desired.

##### 3.1.5 Nonlinear Equations: Newton-Raphson Method

When the PDE is nonlinear, it is easy to see that the algebraic problem is nonlinear as well. Let us consider Burger’s equation,

When we discretize it using a difference method automatically selected by MathPDE, we get the following difference equation, which is nonlinear in .

We then have a system of nonlinear algebraic equations to be solved at each point in time. MathPDE handles such a system using the multidimensional Newton-Raphson method (see [7]). We briefly summarize this method. Suppose we want to solve a system of equations

where is -dimensional. The Newton-Raphson method is an iterative scheme in which the solution at the iteration is

where , and is the Jacobian

When we attempt to perform the iteration equation (12), we must know the initial guess . MathPDE uses the solution at the previous time step as the initial guess for iteratively solving the nonlinear system at every time instant. In particular, for , the initial conditions specified as part of the PDE problem are used as the initial guess. The iteration can be terminated when the difference between successive approximations and is less than a certain small number.

The numerical part involves a matrix problem for both linear and nonlinear PDEs: for the linear case, we have to solve a matrix equation of the kind ; for the nonlinear case, we have to solve such a problem for each iteration. Further, it can be seen that the matrices involved are very sparse, the number of nonzero elements in each row being roughly equal to the degree of FDA. We can thus employ efficient numerical routines to handle sparse matrix systems.

##### 3.1.6 Solution of Sparse Matrix Systems

MathPDE uses the SuperLU numerical library for sparse matrix systems [13]. This optimized library is based on a variation of the Gaussian elimination algorithm adapted for sparse systems, and is actually a collection of three libraries: sequential, multithreaded, and distributed. MathPDE employs a few subroutines of sequential SuperLU to solve matrix equations of the kind that we referred to in Section 3.1.5. The sequential library, implemented in C, supports real and complex data types in both single and double precision.

Here is the basic algorithm on which SuperLU is based, which is a sparse Gaussian elimination procedure to solve a matrix equation .

• Compute an LU decomposition of . Here, and are row and column permutation matrices and and are the so-called equilibration matrices, both diagonal. These four matrices are suitably chosen so as to enhance the sparsity of and , numerical stability, and parallelism. In a simple implementation offered in the subroutine dgssv, the equilibration matrices and are taken to be identity matrices.
• Once we have the LU decomposition, the solution vector can be efficiently computed using , multiplying from right to left.

The sparse matrix must be provided in the Harwell-Boeing column-compressed format to save storage. A row-compressed format is also possible, that is, in which is in column-compressed format, but involves some preprocessing to transform into the Harwell-Boeing format; this is followed in the data structure SuperMatrix. In this storage format, an sparse matrix , in which only elements are nonzero, is specified in terms of three row vectors , , and (that have, respectively, , , and elements).

• The successive elements of are obtained by sequentially going over the columns of , running down each column, and picking the nonzero elements of .
• The elements of are simply the row indices in of the elements of .
• The element of , , for , is the total number of nonzero elements of up to and including the column, and .

Let us illustrate this storage format for the following sparse matrix (taken from the SuperLU user guide [13]).

For this choice of , , , and using the indexing conventions of C, , , and .

Matrices such as these, along with other information like , , and the matrix (that can be specified as a simple row vector of length ) are required by the SuperLU subroutine dgssv that solves the matrix system .

#### 3.2 Domains and Boundaries

##### 3.2.1 Domain Discretization

An important aspect of MathPDE is its ability to handle a wide range of spatial domains. We explain the ideas with the example of a two-dimensional circular domain behind the way MathPDE discretizes domains. Let us therefore begin with a circular domain on which we overlay a grid with 11×11 grid points.

The domain is a circle of radius 1, centered at the origin (the point in the grid). The bounding box is a square with vertices at the points .

In MathPDE, this domain is specified in the format . When we treat this domain descriptor as an iterator, it is clear that all the points inside the unit circle as well as those on its circumference are covered. Furthermore, only these points, and no other, are covered. In other words, the actual domain is a subset of the bounding box. For rectangular domains, the actual domain is the bounding box, whereas for other kinds of geometry, the actual domain is a proper subset of the bounding box. This is made possible because the limits of one of the independent variables, x, are treated as functions of the other independent variable, y.

For our example, here is the lower limit for x.

It is easy to discretize the domain now. Since we know the bounding box, we can obtain the discretized lower limit of x.

Here Nx and Ny are the number of grid points in the bounding box in the x and y directions, respectively. Arguing in the same manner, we have the following formula for the upper limit of x.

This is the overall algorithm we use for discretizing spatial domains. When the domain in question is nonrectangular, there are some issues that we need to be careful about. We now elaborate on some of these, continuing with the example of a circular domain.

Let us list the points lying on the left and right boundaries of the circle.

Here, there is a danger if one is not careful. If the point alone is chosen as being on the circumference on the line , as is done above, then the lower y neighbor of ( in the interior) is the point , which would be outside the domain. Therefore, it is necessary to keep all the points , , …, on the circumference. Here are improved versions of the definitions for xLeft1 and xRight1.

We remark here that formulas xL1 and xR1 lead to extra computation compared with xLeft1 and xRight1. However, since these computations are performed only on the domain boundaries, and not at all the points, the additional burden of this improvised algorithm is insignificant for large grids.

Let us once again look at the left and right boundaries of the circular domain.

Although the differences are only on the lines and , it is important that the neighbors of all interior points are now treated as being on the boundary, and not outside.

There is a shortcoming of this improvised algorithm: since the points , , …, are all treated as being on the circumference of the circular domain, the actual domain used in computations is therefore not exactly circular, but a distorted circle. This is a price we pay for describing nonrectangular domains using a Cartesian system of coordinates. It can be noted, however, that the extent of this distortion is negligible for large grids. In cases where such a distortion affects the quality of solution obtained, one needs to be more careful.

One last point we would like to discuss concerns the notion of subdomains. Above, we mentioned that the domain is specified as , so one could ask why this format is used instead of a simpler iterator like .

The reason is that we want to be able to describe more involved domains like this irregular domain (boundaries shown in solid lines).

This domain can be described using the following list, in which there are two sublists in the x part of the domain descriptor. We call these sublists subdomains. On the other hand, the y part has only one subdomain. It is clear that with this approach, we are able to describe and discretize a wide range of geometries, regular and irregular. The user needs to be able to describe the functional dependence (between independent variables) that defines the nature of geometry.

One last point related to the notion of subdomains concerns the way to describe boundary conditions on a segment of the boundary. Suppose we want to apply a Dirichlet boundary condition on the line joining the points and , which is a segment of the boundary of the domain shown. This is done by including a boundary condition like in the problem list. The iterator corresponding to the boundary above generates the grid points that lie on this boundary segment.

##### 3.2.2 Domain Decomposition: Boundary and Interior Regions

We now discuss the issue of decomposition of the domain into boundary and interior regions, and how to apply the discretized boundary conditions and the difference equations in the respective regions. Let us consider the example of a two-dimensional diffusion equation in a circular domain to illustrate the ideas.

The domain describes a circle that we discussed in the previous subsection. When discretized, it becomes , where the functions xL1 and xR1 were defined earlier. Having discretized the domain, there now remains the problem of decomposing it into boundary and interior regions, where the boundary conditions and the difference equations (corresponding to the PDE) must be applied. We now describe the way in which this is done in MathPDE.

Let us begin by examining the boundary conditions. In the present example, we have two Dirichlet boundary conditions for at the left and right branches of the circular domain, and .

Clearly, the interior region begins with the point and ends with the point at each value of . Furthermore, the points on the circumference for , namely, (for ), as well as the points on the circumference for , , must be part of the boundary. As a result, the boundaries are described by list1 and list2 and the interior region described by list3 .

This is the overall domain decomposition algorithm that MathPDE implements. We now elaborate on a few issues that arise in connection with matching the difference equations and the boundary conditions at the boundary.

When the lowest-degree difference approximation is used to generate the difference equations from the PDE (see Section 3.1.1), the domain for the circle above determines the set of grid points at which the difference equations apply. However, when we use a higher-degree difference approximation, matching the difference equations with the boundary conditions is a tricky issue. As we have already mentioned in Section 3.1.4, we use the lowest-degree stencil on a few grid layers near the boundary, with the higher-degree stencil taking over beyond this region into the interior. As a result, the interior region for the circle must be further decomposed into two subregions: a few layers near the boundary where the lowest-degree difference equations apply, and the rest of the interior region where higher-degree equations apply.

For example, here is the difference equation when a fourth-degree spatial scheme is used for the two-dimensional diffusion equation.

This equation has the y values . Since the lowest grid value of y is 1, it is clear that this equation can be applied only for y beginning with . Similarly, the highest grid value of y at which the equation can be applied is . We can argue in the same way for the x limits, and as a result, the interior region where the fourth-degree stencil applies is stencil4.

The region where the lowest-degree (i.e., second-degree in this case) stencil applies is this set of four regions, which is the difference between the regions list3 and stencil4.

Finally, we comment on a correction required in the definitions of xL1 and xR1 that describe the boundary region. The left and right boundaries that make up the circular domain meet on the lines and . As we argued in Section 3.2.1, the boundary intersects each of these lines at a set of points, and not just one point. As a result, all the points from to must be included in the boundary region; similarly, all the points from to must also be included in the boundary region. The original definitions of xL1 and xR1 do not include all these points, and we must therefore replace them by the set of regions that correctly describes the boundary region.

This list also ensures that points where two boundaries intersect are included in only one of them, and not counted twice. The domain decomposition algorithm implemented by MathPDE takes this into account.

#### 3.3 Code Generation Algorithms

##### 3.3.1 Automatic Function Generation

In the previous two sections, 3.1 and 3.2, we discussed at length the numerical and domain-related algorithms that MathPDE implements. A third important component of MathPDE is its ability to generate a problem-specific program by stitching together the numerical and domain parts in an appropriate manner. This program is a set of independent and interrelated Mathematica functions that work to compute a numerical solution of the PDE problem. Each function performs a very specific task.

For example, consider the function that we discussed in Section 3.2.1, which computes the lower limit of the iterator for x in a circular domain. This is one of the many functions that are automatically generated by MathPDE for the PDE problem diffusion2dcircle. The way we do this is by manipulating the DownValues of the function. Since is a list of elements of the form , we can define lhs and rhs suitably, and generate a definition of the function xL1. Let us briefly explain how we do it.

We first generate the list deflist after creating a context MathPDE`, whose elements are of the form .

This list is generated based on the domain-discretization algorithm as explained in Section 3.2.1. Here, lhs contains information about the input syntax (the function prototype, without type information) of the function head, and rhs contains what is going to be the body of the function definition. Note that the Rule format ensures delayed evaluation. Once we have a list like deflist, it is easy to generate function definitions. We can, for instance, define a function-defining function called DefineFunction that can generate the definition of a function based on information like deflist.

Now, we can execute the following commands.

After which, the functions xL1 and xLeft1 will be defined.

We note one more thing here. Since the body of xL1 depends explicitly on another function, xLeft1, it is important that the latter be still undefined when the former is defined. The sequence of function generations must therefore be arranged with proper regard for their interdependence. One more thing to note is that the body of each of the functions automatically generated must involve purely numerical operations and no symbolic ones. This is important, since we are finally interested in translating the program into a compiled language (like C++ or Fortran 90) by employing the code generator MathCode [14].

Some of the functions automatically generated do not have such a simple structure as xL1. These include, for instance, the function SolvePDE that we encountered in Section 2. Such functions perform more complicated operations, and involve local variables that must be declared in a Module. Such definitions are generated using special-purpose functions available in MathPDE, and functions like DefineFunction above will not do. However, the essential idea is still the same, and is based on delayed evaluation and the use of DownValues.

##### 3.3.2 Translation into C++ Using MathCode

MathCode is a system for translating Mathematica functions into C++/Fortran 90 [14]. The functions must be purely numerical, as we mentioned in Section 3.3.1. We must declare the prototype information of the functions for MathCode to translate them. The numerical functions that MathPDE generates are then passed on to MathCode, which in turn translates them into C++ or Fortran 90.

The reason for translating the Mathematica functions is twofold. Firstly, it lends portability to the solver: the C++ code that is generated is completely self-contained. Secondly, MathCode enables us to run the generated code from the notebook as well. Typically, this leads to performance gains of several times compared with original Mathematica code.

We now illustrate the way MathPDE employs MathCode to generate C++ code.

We have to start the context MathPDE`, and mention MathCodeContexts within the path of the package.

However, since the functions xL1 and xLeft1 have already been defined, we simply end the package.

We next declare the function prototypes. This specifies the data types of all the arguments and the output. In our simple example, all data types involved are integers.

We then build the C++ code for the functions xL1 and xLeft1 with the following command.

The next command runs the Mathematica code for the function xL1.

If we want to run the C++ executable instead, we must install it.

Now this runs the C++ executable.

It can be seen that there is a slight enhancement in speed; however, the enhancement factor depends on the problem. Here is the C++ code generated.

We compiled just two functions, xL1 and xLeft1. MathPDE automates this sequence of commands and generates, compiles, and installs code for all the numerical functions automatically generated for the given PDE problem (nine functions, for the example of the one-dimensional diffusion equation; see Section 2.2). The resulting code computes the solution to the PDE, as demonstrated in Section 2.3.

### 4. Examples

This section presents a range of example PDE problems solved using MathPDE: the examples are chosen to illustrate the many features of MathPDE; for example, higher-degree approximation schemes, nonlinear problems, different kinds of boundary condition, non-rectangular geometries, and so on. All the problems are time-dependent PDE problems, mainly of the parabolic and hyperbolic types.

We now solve a variety of PDE problems using MathPDE. The solution steps involved are much like in Section 2, and are obvious from the context. If MathPDE is installed on your system, all the commands should work when executed in the sequence they are given in below.

#### 4.1 One-Dimensional Problems

##### 4.1.1 Diffusion Equation with Derivative Boundary Conditions

We must first load the package MathPDE.

To save space here as well as in the rest of Section 4, we have cut out the detailed comments returned by MathPDE when the function SetupMathPDE is executed.

The difference here from the example presented in Section 4 is that the derivative at the left end of the system is zero, which leads to a different solution profile. In both cases, however, the solutions decay to a uniform concentration distribution in the long time limit.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

##### 4.1.2 Wave Equation

We must first load the package MathPDE.

In this case, we can choose numerical values for c and der1 at run time; the code generated for SolvePDE is such that these parameters can be passed as real arguments when we execute the program. We now run SolvePDE by choosing numerical values for these parameters.

We can choose a different set of values for the parameters of the problem.

The solution is now different.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

#### 4.2 Two-Dimensional Problems

##### 4.2.1 Diffusion Equation in a Rectangular Domain

We now take the example of a two-dimensional diffusion equation and compare MathPDE and NDSolve, the built-in Mathematica function to solve time-dependent PDE problems. We take the initial condition that is a Gaussian with its peak at the center of the domain, and Dirichlet boundary conditions.

NDSolve uses the numerical method of lines, while MathPDE uses a finite-difference time stepping. This could partly explain the differences in the solutions obtained by the two approaches.

We must first load the package MathPDE.

Let us set up the problem in MathPDE.

Now let us evolve the solution by 10 time steps.

We plot the solution.

We can try this example using NDSolve as well. Let us choose the same step sizes as chosen above for MathPDE so as to compare the two solutions.

We plot the solution at .

The solution has not homogenized yet, although the solution obtained using MathPDE was more spread out. However, suppose we let NDSolve automatically choose its step sizes.

We now plot the solution profile at .

Now the solution is more spread out, and agrees with the solution produced by MathPDE.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

##### 4.2.2 Diffusion Equation on a Circle

We now consider an example PDE problem with a circular domain; apart from that, the problem is essentially the same as in the previous example. This is a problem that NDSolve cannot handle, since the spatial geometry is not rectangular.

We must first load the package MathPDE.

The boundary conditions are specified on the left and right semicircles. Since we describe a nonrectangular domain using Cartesian coordinates, one of the coordinates, x, has been made to depend on the other, y, in the domain description.

We now set up the problem using MathPDE.

In this case MathPDE has generated 21 functions (as opposed to 13 in the previous example) that are translated into C++ code and compiled by MathCode. The extra functions in this case are required to compute the grid for the circular domain.

We compute the solution and plot it.

Although we use Cartesian coordinates to describe a circular domain, the jagged nature of the circular boundary is not predominant at this level of granularity (50 grid steps in each of the two directions), and the solution appears fairly smooth.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

##### 4.2.3 A Two-Variable Problem: Wave Equation in a Circular Domain

We now study the example of the two-dimensional wave equation, in which there are two dependent variables. Let us first consider a rectangular domain.

We must first load the package MathPDE.

In this problem, there are some parameters, and so we have to input them in a list as an argument to the setup function.

Let us now compute the solution for a set of values of the parameters.

Here is the plot of the dependent variable u.

And here is the plot of the dependent variable v.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

Now consider a similar problem in a circular domain.

We must first load the package MathPDE.

Here is the plot of the dependent variable u.

And here is the plot of the dependent variable v.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

#### 4.3 A Three-Dimensional Problem

##### 4.3.1 Three-Dimensional Wave Equation

Let us now consider the wave equation

for the spatial and temporal variations of , the three-dimensional vector of displacements in a solid. Here, is the speed of sound in the material, and and are constants that depend on the Poisson ratio. This equation arises in many contexts, for example when we have a shaft that rests on ball bearings and is connected to wheels at the ends. We can describe this problem in a cubic geometry in the form of the following list, in which we have expanded the vector equation into components.

We must first load the package MathPDE.

Here we have taken simple Dirichlet boundary conditions; the practically interesting cases could have Robin boundary conditions involving normal derivatives of the fields, in which case we would need to do a little more work to transform the normal derivatives into suitable combinations of derivatives with respect to Cartesian coordinates.

For this problem, we use a slightly different version of the setup function that does not make MathCode-related declarations; it returns a list that has the prototype information about the functions for which C++ code is desired.

We now apply the function MathCodePart to the list mcode to make declarations, generate C++ code, compile it, and install the executable.

Let us run SolvePDE by taking , and . The parameter values are .

Let us define a function to extract function values (for u) over a two-dimensional cross section.

Here is the plot of the dependent variable u over a two-dimensional cross section for .

We can plot the other dependent variables v and w in the same manner. Let us define a function to extract function values for v over a two-dimensional cross section.

Here is the plot of the dependent variable v over a two-dimensional cross section for .

Finally, let us define a function to extract function values for w over a two-dimensional cross section.

Here is the plot of the dependent variable w over a two-dimensional cross section for .

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

#### 4.4 Nonlinear Problems

##### 4.4.1 Advection-Diffusion and Inviscid Burger’s Equations

Let us now consider the following PDE

where is a constant. When , the equation becomes the inviscid Burger’s equation, and when , the equation becomes the advection-diffusion equation. Let us define this PDE problem with Dirichlet boundary conditions and a simple space-dependent initial condition.

We must first load the package MathPDE.

In this case, the PDE leads to a nonlinear algebraic system that must be solved iteratively. Let us choose a small time step of 0.01 and evolve the solution by 100 time steps (i.e., up to ) for a spatial size of 100 grid points. We first choose , so we have the advection-diffusion limit.

We now solve the problem with : in this limit, we have the inviscid Burger’s equation.

The solution varies very strongly in space near the right boundary. This indicates that finite-difference approximation is not very good for such problems. Indeed, if we evolve the solution by a further 15 time steps, we can see the quality of the solution deteriorate further.

Now there are wild fluctuations near the right boundary, and the solution is not reliable. Let us solve the problem using NDSolve.

At , let us plot the solution.

This agrees well with the solution obtained using MathPDE, and the rapid fall near the right end of the system must be noticed. Let us now plot the solution at a later time, .

Now we can see that there are regions where the solution shows strong fluctuations, although there are differences between the solutions obtained by MathPDE and NDSolve.

Examples such as these illustrate the limitations of MathPDE, based as it is on finite-difference discretization.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

##### 4.4.2 A Nonlinear Variant of the Diffusion Equation

Now let us try a nonlinear variant of the diffusion equation.

We must first load the package MathPDE.

When we take , the solution is very different.

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

Consider the same PDE, but with a derivative boundary condition at .

We must first load the package MathPDE.

We solve it for .

Now the solution profile is different, because the derivative at the left boundary must be zero, according to the boundary condition. Finally, we solve it for .

We can uninstall the C++ program, and delete all the MathCode-related files if we do not need them.

We must quit the kernel before testing a new problem.

### 5. Conclusion

In this article, we have presented a PDE solving system, MathPDE, that is based on Mathematica. We have demonstrated it for a variety of time-dependent PDE problems, and made comparisons with NDSolve in a few cases.

We have discussed at length the basic ideas underlying the design of MathPDE. We believe that there is scope for improvement in many areas, like the adaptive step sizes for space and time, the way in which higher-degree approximations are implemented, and so on. The limitations of MathPDE for nonlinear problems are obvious, based as it is on finite differences.

The main attractions of MathPDE are its ability to handle a wide range of spatial domains and the generation of a standalone C++ program for performing numerical computation.

### References

 [1] H. P. Langtangen, “Computational Partial Differential Equations: Numerical Methods and Diffpack Programming,” Lecture Notes in Computational Science and Engineering, Vol. 2, Berlin: Springer-Verlag, 1999. [2] J. R. Rice and R. F. Boisvert, Solving Elliptic Problems Using ELLPACK, New York: Springer, 1985. www.cs.purdue.edu/ellpack/ellpack.html. [3] E. Mossberg, K. Otto, and M. Thuné, “Object-Oriented Software Tools for the Construction of Preconditioners,” Scientific Programming, 6(3), 1997 pp. 285-295.www.informatik.uni-trier.de/~ley/db/journals/sp/sp6.html. [4] K. Åhlander, “An Object-Oriented Framework for PDE Solvers,” Ph.D. thesis, Department of Scientific Computing, Uppsala University, Sweden, 1999.uu.diva-portal.org/smash/record.jsf?pid=diva2:162116. [5] W. D. Henshaw. “Overture Documentation, LLNL Overlapping Grid Project.” (May 23, 2011) www.llnl.gov/CASC/Overture/henshaw/overtureDocumentation/overtureDocumentation.html. [6] W. F. Ames, Numerical Methods for Partial Differential Equations, 3rd ed., San Diego: Academic Press, 1992. [7] C. F. Gerald and P. O. Wheatley, Applied Numerical Analysis, 5th ed., Reading, MA: Addison-Wesley, 1994. [8] B. Gustafsson, H.-O. Kreiss, and J. Oliger, Time Dependent Problems and Difference Methods, New York: Wiley, 1995. [9] M. Oh, “Modeling and Simulation of Combined Lumped and Distributed Processes,” Ph.D. thesis, University of London, 1995. [10] K. Sheshadri and P. Fritzson, “A Mathematica-Based PDE Solver Generator,” Proceedings of SIMS’99, Conference of the Scandinavian Simulation Society, Linköping, Sweden, 1999 pp. 66-78. [11] K. Sheshadri and P. Fritzson, “A General Symbolic PDE Solver Generator: Explicit Schemes,” Scientific Programming, 11(1), 2003 pp. 39-55.dl.acm.org/citation.cfm?id=1240066&CFID=40011545&CFTOKEN=28188005. [12] K. Sheshadri and P. Fritzson, “A General Symbolic PDE Solver Generator: Beyond Explicit Schemes,” Scientific Programming, 11(3), 2003 pp. 225-235.dl.acm.org/citation.cfm?id=1240103. [13] J. W. Demmel, J. R. Gilbert, and X. S. Li, SuperLU Users’ Guide.crd.lbl.gov/~xiaoye/SuperLU. [14] P. Fritzson, MathCode C++, Linköping, Sweden: MathCore Engineering AB, 1998. www.mathcore.com. [15] B. Fornberg, “Calculation of Weights in Finite Difference Formulas,” SIAM Review, 40(3), 1998 pp. 685-691. amath.colorado.edu/faculty/fornberg/Docs/sirev_cl.pdf. K. Sheshadri and P. Fritzson, “MathPDE: A Package to Solve PDEs by Finite Differences,” The Mathematica Journal, 2011. dx.doi.org/doi:10.3888/tmj.13-20.