My research addresses a variety of problems in scientific computing and computational mechanics. Areas of interest and activity include numerical analysis, software development methodologies and new numerical methods, as well as applications in solid mechanics, fluid mechanics, materials science and geophysics. The page presents some specific examples of past and ongoing research.

*This page is presently being populated.*

Much of this research is carried out with collaborators under the umbrella of the FEniCS Project (http://www.fenicsproject.org). A book on the FEniCS Project was published by Springer in 2012 (http://dx.doi.org/10.1007/978-3-642-23099-8). The book is available under the Creative Commons license at http://tinyurl.com/fenics-book.

Domain-specific languages (DSL) are tailored to specific application
areas. We work, together with collaborators, on the Unified Form
Language (UFL) for the numerical solution of partial differential
equations. The aim is to provide an expressive language that mirror
mathematical syntax. Specifically, UFL works with partial
differential equations posed in a *weak* form.

UFL can be used for many different equations and in different application fields. It has been applied to a variety of complex, coupled nonlinear equations. For the Poisson equation the weak form the of Poisson equations is expressed as: find \(u \in V\) such that

\[\int_{\Omega} \nabla u \cdot \nabla v \, d\Omega
= \int_{\Omega} fv \, d\Omega \quad \forall \ v \in V\]

The UFL input for this problem using a linear finite element basis is

```
V = FiniteElement("Lagrange", triangle, 1)
u = TrialFunction(V)
v = TestFunction(V)
f = Coefficient(V)
a = dot(grad(u), grad(v))*dx
L = f*v*dx
```

The UFL input mirrors the mathematical abstractions and syntax. From the high-level UFL input, a code generator can produce low-level computer code in a generic language automatically.

UFL is described in detail in the paper http://arxiv.org/abs/1211.4047 that will appear in ACM Transactions on Mathematical Software.

Our research into domain-specific compilers has shown that automated computer code generation can lead to highly efficient computer code. Computer code can be generated rapidly from high-level input, and the specialised optimisation applied can outperform standard compiler optimisations by more than an order of magnitude.

The below code is a complete program for the diffusion-reaction equation.

```
# Import module
from dolfin import *
# Define problem
mesh = UnitCube(64, 64, 64)
V = FunctionSpace(mesh, "CG", 1)
u = TrialFunction(V)
v = TestFunction(V)
f = Expression("sin(x[0])*sin(x[1])")
a = dot(grad(u), grad(v))*dx + u*v*dx
L = f*v*dx
# Compute and plot solution to the screen
problem = VariationalProblem(a, L)
u = problem.solve()
plot(u, interactive=True)
```

This simple program can be run without modification in parallel on hundreds of processors via MPI.

The solution of large-scale, three-dimensional problems is demanding in terms of computational resources and demands sophisticated, parallel solution techniques.

The same mesh is shown below using X3DOM (http://www.x3dom.org/). You need a browser that supports WebGL to view the interactive gear. It can be rotated and zoomed interactively.

The vast majority of scientific and engineering problems involve uncertainty. To interpret the results of computer simulations, probabilistic information is very important. Methods are being developed to quantify the impact of uncertainties on computed results for challenging physical systems and the control of engineering systems. See http://dx.doi.org/10.1016/j.cma.2011.11.026.

The development of microstructure impacts heavily on the properties of alloys. The formation of different microstructures is driven by different physical processes that can act on vastly different time scales.