def test_structured(tol=1E-15):
'Test with structured non-uniform mesh. Fenicstools vs matrix.'
passed = []
for d in [1, 2, 3]:
if d == 1:
mesh = UnitIntervalMesh(20)
mesh.coordinates()[:] = np.cos(2*pi*mesh.coordinates())
elif d == 2:
mesh = UnitSquareMesh(20, 20)
mesh.coordinates()[:] = np.cos(2*pi*mesh.coordinates())
else:
mesh = UnitCubeMesh(5, 5, 5)
mesh.coordinates()[:, 0] = mesh.coordinates()[:, 0]**3
mesh.coordinates()[:, 1] = mesh.coordinates()[:, 1]**2
mesh.coordinates()[:, 2] = mesh.coordinates()[:, 2]**2
for j in range(d):
WP = build_WP(mesh, 'harmonic', i=j).array()
F_WP = f_build_WP(mesh, i=j).array()
e = np.linalg.norm(WP - F_WP)/WP.shape[0]
passed.append(e < tol)
assert(all(passed))
def test_diff_then_integrate():
# Define 1D geometry
n = 21
mesh = UnitIntervalMesh(MPI.comm_world, n)
# Shift and scale mesh
x0, x1 = 1.5, 3.14
mesh.coordinates()[:] *= (x1 - x0)
mesh.coordinates()[:] += x0
x = SpatialCoordinate(mesh)[0]
xs = 0.1 + 0.8 * x / x1 # scaled to be within [0.1,0.9]
# Define list of expressions to test, and configure
# accuracies these expressions are known to pass with.
# The reason some functions are less accurately integrated is
# likely that the default choice of quadrature rule is not perfect
F_list = []
def reg(exprs, acc=10):
for expr in exprs:
F_list.append((expr, acc))
# FIXME: 0*dx and 1*dx fails in the ufl-ffc-jit framework somewhere
# reg([Constant(0.0, cell=cell)])
# reg([Constant(1.0, cell=cell)])
monomial_list = [x**q for q in range(2, 6)]
reg(monomial_list)
reg([2.3 * p + 4.5 * q for p in monomial_list for q in monomial_list])
reg([x**x])
reg([x**(x**2)], 8)
reg([x**(x**3)], 6)
reg([x**(x**4)], 2)
# Special functions:
reg([atan(xs)], 8)
reg([sin(x), cos(x), exp(x)], 5)
reg([ln(xs), pow(x, 2.7), pow(2.7, x)], 3)
reg([asin(xs), acos(xs)], 1)
reg([tan(xs)], 7)
try:
import scipy
except ImportError:
scipy = None
if hasattr(math, 'erf') or scipy is not None:
reg([erf(xs)])
else:
print(
"Warning: skipping test of erf, old python version and no scipy.")
# if 0:
# print("Warning: skipping tests of bessel functions, doesn't build on all platforms.")
# elif scipy is None:
# print("Warning: skipping tests of bessel functions, missing scipy.")
# else:
# for nu in (0, 1, 2):
# # Many of these are possibly more accurately integrated,
# # but 4 covers all and is sufficient for this test
# reg([bessel_J(nu, xs), bessel_Y(nu, xs), bessel_I(nu, xs), bessel_K(nu, xs)], 4)
# To handle tensor algebra, make an x dependent input tensor
# xx and square all expressions
def reg2(exprs, acc=10):
for expr in exprs:
F_list.append((inner(expr, expr), acc))
xx = as_matrix([[2 * x**2, 3 * x**3], [11 * x**5, 7 * x**4]])
x3v = as_vector([3 * x**2, 5 * x**3, 7 * x**4])
cc = as_matrix([[2, 3], [4, 5]])
reg2([xx])
reg2([x3v])
reg2([cross(3 * x3v, as_vector([-x3v[1], x3v[0], x3v[2]]))])
reg2([xx.T])
reg2([tr(xx)])
reg2([det(xx)])
reg2([dot(xx, 0.1 * xx)])
reg2([outer(xx, xx.T)])
reg2([dev(xx)])
reg2([sym(xx)])
reg2([skew(xx)])
reg2([elem_mult(7 * xx, cc)])
reg2([elem_div(7 * xx, xx + cc)])
reg2([elem_pow(1e-3 * xx, 1e-3 * cc)])
reg2([elem_pow(1e-3 * cc, 1e-3 * xx)])
reg2([elem_op(lambda z: sin(z) + 2, 0.03 * xx)], 2) # pretty inaccurate...
# FIXME: Add tests for all UFL operators:
# These cause discontinuities and may be harder to test in the
# above fashion:
# 'inv', 'cofac',
# 'eq', 'ne', 'le', 'ge', 'lt', 'gt', 'And', 'Or', 'Not',
# 'conditional', 'sign',
# 'jump', 'avg',
# 'LiftingFunction', 'LiftingOperator',
# FIXME: Test other derivatives: (but algorithms for operator
# derivatives are the same!):
# 'variable', 'diff',
# 'Dx', 'grad', 'div', 'curl', 'rot', 'Dn', 'exterior_derivative',
# Run through all operators defined above and compare integrals
debug = 0
for F, acc in F_list:
# Apply UFL differentiation
f = diff(F, SpatialCoordinate(mesh))[..., 0]
if debug:
print(F)
print(x)
print(f)
# Apply integration with DOLFIN
# (also passes through form compilation and jit)
M = f * dx
f_integral = assemble_scalar(M) # noqa
f_integral = MPI.sum(mesh.mpi_comm(), f_integral)
# Compute integral of f manually from anti-derivative F
# (passes through PyDOLFIN interface and uses UFL evaluation)
F_diff = F((x1, )) - F((x0, ))
# Compare results. Using custom relative delta instead
# of decimal digits here because some numbers are >> 1.
delta = min(abs(f_integral), abs(F_diff)) * 10**-acc
assert f_integral - F_diff <= delta
cinferr = Z.max()
l2err = np.sqrt(l2err)
l2errtrap = 0
for j in range(len(ydofs) - 1):
vdiff = Function(Vx)
vdiff.vector().set_local(0.5 * (Z[j, :] + Z[j + 1, :]))
l2errtrap += np.power(norm(vdiff, 'L2'), 2) * ydiff[j]
# Compute L2 error by trapezoidal rule
l2errtrap = np.sqrt(l2errtrap)
L2errTrap.append(l2errtrap)
ndofs = len(ydofs) * len(xdofs)
Ndofs.append(ndofs)
hxmax = max(np.diff(np.sort(mx.coordinates().flatten())))
hymax = ydiff.max()
hmax = np.maximum(hxmax, hymax)
Hmax.append(hmax)
L2err.append(l2err)
Cinferr.append(cinferr)
Nt.append(nt)
print('Step: ', step)
print('Ndofs: ', ndofs)
print('Hmax: ', hmax)
print('L2 err: ', l2err)
print('L2 err (trapezoidal): ', l2errtrap)
print('Cinf err: ', cinferr)
if writeErrors:
