A FEniCS Tutorial - FEniCS Project

e_Ve.vector()[:] = u_e_Ve.vector().array() - \
u_Ve.vector().array()
error = e_Ve**2*dx
return sqrt(assemble(error))
The errornorm procedure turns out to be identical to computing the expression
(u_e - u)**2*dx directly in the present test case.
Sometimes it is of interest to compute the error of the gradient field: ||∇(u−
ue)|| (often referred to as the H 1 seminorm of the error). Given the error field
e_Ve above, we simply write
H1seminorm = sqrt(assemble(inner(grad(e_Ve), grad(e_Ve))*dx))
Finally, we remove all plot calls and printouts of u values in the original
program, and collect the computations in a function:
def compute(nx, ny, degree):
mesh = UnitSquare(nx, ny)
V = FunctionSpace(mesh, ’Lagrange’, degree=degree)
...
Ve = FunctionSpace(mesh, ’Lagrange’, degree=5)
E = errornorm(u_e, u, Ve)
return E
Calling compute for finer and finer meshes enables us to study the convergence
rate. Define the element size h = 1/n, where n is the number of
divisions in x and y direction (nx=ny in the code). We perform experiments
with h 0 > h 1 > h 2··· and compute the corresponding errors E 0 ,E 1 ,E 3 and so
forth. Assuming E i = Ch r i for unknown constants C and r, we can compare
two consecutive experiments, E i = Ch r i and E i−1 = Ch r i−1 , and solve for r:
r = ln(E i/E i−1 )
ln(h i /h i−1 ) .
The r values should approach the expected convergence rate degree+1 as i
increases.
The procedure above can easily be turned into Python code:
import sys
degree = int(sys.argv[1]) # read degree as 1st command-line arg
h = [] # element sizes
E = [] # errors
for nx in [4, 8, 16, 32, 64, 128, 264]:
h.append(1.0/nx)
E.append(compute(nx, nx, degree))
# Convergence rates
from math import log as ln # (log is a dolfin name too - and logg :-)
for i in range(1, len(E)):
r = ln(E[i]/E[i-1])/ln(h[i]/h[i-1])
print ’h=%10.2E r=.2f’ (h[i], r)
33