A FEniCS Tutorial - FEniCS Project

def boundary(x, on_boundary):
return on_boundary
bc = DirichletBC(V, Constant(0.0), boundary)
omega = 1.0
u_e = Expression(’sin(omega*pi*x[0])*sin(omega*pi*x[1])’,
omega=omega)
f = 2*pi**2*omega**2*u_e
The computation of (∫ Ω (u e −u) 2 dx ) 1/2
can be done by
error = (u - u_e)**2*dx
E = sqrt(assemble(error))
Here, u_e will be interpolated onto the function space V. This implies that the
exact solution used in the integral will vary linearly over the cells, and not as a
sine function, if V corresponds to linear Lagrange elements. This situation may
yield a smaller error u - u_e than what is actually true.
More accurate representation of the exact solution is easily achieved by interpolating
the formula onto a space defined by higher-order elements, say of
third degree:
Ve = FunctionSpace(mesh, ’Lagrange’, degree=3)
u_e_Ve = interpolate(u_e, Ve)
error = (u - u_e_Ve)**2*dx
E = sqrt(assemble(error))
To achieve complete mathematical control of which function space the computations
are carried out in, we can explicitly interpolate u to the same space:
u_Ve = interpolate(u, Ve)
error = (u_Ve - u_e_Ve)**2*dx
The square in the expression for error will be expanded and lead to a
lot of terms that almost cancel when the error is small, with the potential of
introducing significant round-off errors. The function errornorm is available
for avoiding this effect by first interpolating u and u_e to a space with higherorder
elements, then subtracting the degrees of freedom, and then performing
the integration of the error field. The usage is simple:
E = errornorm(u_e, u, normtype=’L2’, degree=3)
It is illustrative to look at the short implementation of errornorm:
def errornorm(u_e, u, Ve):
u_Ve = interpolate(u, Ve)
u_e_Ve = interpolate(u_e, Ve)
e_Ve = Function(Ve)
# Subtract degrees of freedom for the error field
32