def test_complex_assembly_solve():
"""Solve a positive definite helmholtz problem and verify solution
with the method of manufactured solutions
"""
degree = 3
mesh = dolfin.generation.UnitSquareMesh(dolfin.MPI.comm_world, 20, 20)
P = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), degree)
V = dolfin.function.functionspace.FunctionSpace(mesh, P)
x = SpatialCoordinate(mesh)
# Define source term
A = 1 + 2 * (2 * np.pi)**2
f = (1. + 1j) * A * ufl.cos(2 * np.pi * x[0]) * ufl.cos(2 * np.pi * x[1])
# Variational problem
u = dolfin.function.argument.TrialFunction(V)
v = dolfin.function.argument.TestFunction(V)
C = 1 + 1j
a = C * inner(grad(u), grad(v)) * dx + C * inner(u, v) * dx
L = inner(f, v) * dx
# Assemble
A = dolfin.fem.assemble_matrix(a)
A.assemble()
b = dolfin.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
# Create solver
solver = dolfin.cpp.la.PETScKrylovSolver(mesh.mpi_comm())
dolfin.cpp.la.PETScOptions.set("ksp_type", "preonly")
dolfin.cpp.la.PETScOptions.set("pc_type", "lu")
solver.set_from_options()
x = A.createVecRight()
solver.set_operator(A)
solver.solve(x, b)
# Reference Solution
def ref_eval(values, x):
values[:,
0] = np.cos(2 * np.pi * x[:, 0]) * np.cos(2 * np.pi * x[:, 1])
u_ref = dolfin.interpolate(ref_eval, V)
xnorm = x.norm(PETSc.NormType.N2)
x_ref_norm = u_ref.vector.norm(PETSc.NormType.N2)
assert np.isclose(xnorm, x_ref_norm)
def test_assemble_functional():
mesh = dolfin.generation.UnitSquareMesh(dolfin.MPI.comm_world, 12, 12)
M = 1.0 * dx(domain=mesh)
value = dolfin.fem.assemble_scalar(M)
value = dolfin.MPI.sum(mesh.mpi_comm(), value)
assert value == pytest.approx(1.0, 1e-12)
x = SpatialCoordinate(mesh)
M = x[0] * dx(domain=mesh)
value = dolfin.fem.assemble_scalar(M)
value = dolfin.MPI.sum(mesh.mpi_comm(), value)
assert value == pytest.approx(0.5, 1e-12)
def test_complex_assembly():
"""Test assembly of complex matrices and vectors"""
mesh = dolfin.generation.UnitSquareMesh(dolfin.MPI.comm_world, 10, 10)
P2 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 2)
V = dolfin.function.functionspace.FunctionSpace(mesh, P2)
u = dolfin.function.argument.TrialFunction(V)
v = dolfin.function.argument.TestFunction(V)
g = -2 + 3.0j
j = 1.0j
a_real = inner(u, v) * dx
L1 = inner(g, v) * dx
b = dolfin.fem.assemble_vector(L1)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
bnorm = b.norm(PETSc.NormType.N1)
b_norm_ref = abs(-2 + 3.0j)
assert np.isclose(bnorm, b_norm_ref)
A = dolfin.fem.assemble_matrix(a_real)
A.assemble()
A0_norm = A.norm(PETSc.NormType.FROBENIUS)
x = SpatialCoordinate(mesh)
a_imag = j * inner(u, v) * dx
f = 1j * ufl.sin(2 * np.pi * x[0])
L0 = inner(f, v) * dx
A = dolfin.fem.assemble_matrix(a_imag)
A.assemble()
A1_norm = A.norm(PETSc.NormType.FROBENIUS)
assert np.isclose(A0_norm, A1_norm)
b = dolfin.fem.assemble_vector(L0)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
b1_norm = b.norm(PETSc.NormType.N2)
a_complex = (1 + j) * inner(u, v) * dx
f = ufl.sin(2 * np.pi * x[0])
L2 = inner(f, v) * dx
A = dolfin.fem.assemble_matrix(a_complex)
A.assemble()
A2_norm = A.norm(PETSc.NormType.FROBENIUS)
assert np.isclose(A1_norm, A2_norm / np.sqrt(2))
b = dolfin.fem.assemble_vector(L2)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
b2_norm = b.norm(PETSc.NormType.N2)
assert np.isclose(b2_norm, b1_norm)
# and a :py:class:`TestFunction # <dolfin.functions.function.TrialFunction>` on the previously defined # :py:class:`FunctionSpace # <dolfin.functions.functionspace.FunctionSpace>` ``V``. # # Further, the source :math:`f` and the boundary normal derivative # :math:`g` are involved in the variational forms, and hence we must # specify these. # # With these ingredients, we can write down the bilinear form ``a`` and # the linear form ``L`` (using UFL operators). In summary, this reads :: # Define variational problem u = TrialFunction(V) v = TestFunction(V) x = SpatialCoordinate(mesh) f = 10 * ufl.exp(-((x[0] - 0.5)**2 + (x[1] - 0.5)**2) / 0.02) g = ufl.sin(5 * x[0]) a = inner(grad(u), grad(v)) * dx L = inner(f, v) * dx + inner(g, v) * ds # Now, we have specified the variational forms and can consider the # solution of the variational problem. First, we need to define a # :py:class:`Function <dolfin.functions.function.Function>` ``u`` to # represent the solution. (Upon initialization, it is simply set to the # zero function.) A :py:class:`Function # <dolfin.functions.function.Function>` represents a function living in # a finite element function space. Next, we can call the :py:func:`solve # <dolfin.fem.solving.solve>` function with the arguments ``a == L``, # ``u`` and ``bc`` as follows: ::
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
def test_div_grad_then_integrate_over_cells_and_boundary():
# Define 2D geometry
n = 10
mesh = RectangleMesh(Point(0.0, 0.0), Point(2.0, 3.0), 2 * n, 3 * n)
x, y = SpatialCoordinate(mesh)
xs = 0.1 + 0.8 * x / 2 # scaled to be within [0.1,0.9]
# ys = 0.1 + 0.8 * y / 3 # scaled to be within [0.1,0.9]
n = FacetNormal(mesh)
# 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([xs**xs])
reg(
[xs**(xs**2)], 8
) # Note: Accuracies here are from 1D case, not checked against 2D results.
reg([xs**(xs**3)], 6)
reg([xs**(xs**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)
# 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]])
xxs = as_matrix([[2 * xs**2, 3 * xs**3], [11 * xs**5, 7 * xs**4]])
x3v = as_vector([3 * x**2, 5 * x**3, 7 * x**4])
cc = as_matrix([[2, 3], [4, 5]])
reg2(
[xx]
) # TODO: Make unit test for UFL from this, results in listtensor with free indices
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 * xxs, 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
if debug:
F_list = F_list[1:]
for F, acc in F_list:
if debug:
print('\n', "F:", str(F))
# Integrate over domain and its boundary
int_dx = assemble(div(grad(F)) * dx(mesh)) # noqa
int_ds = assemble(dot(grad(F), n) * ds(mesh)) # noqa
if debug:
print(int_dx, int_ds)
# Compare results. Using custom relative delta instead of
# decimal digits here because some numbers are >> 1.
delta = min(abs(int_dx), abs(int_ds)) * 10**-acc
assert int_dx - int_ds <= delta