def test_adjoint():
cell = triangle
V1 = FiniteElement("CG", cell, 1)
V2 = FiniteElement("CG", cell, 2)
u = TrialFunction(V1)
v = TestFunction(V2)
assert u.number() > v.number()
u2 = Argument(V1, 2)
v2 = Argument(V2, 3)
assert u2.number() < v2.number()
a = u * v * dx
a_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(a)]
assert a_arg_degrees == [2, 1]
b = adjoint(a)
b_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(b)]
assert b_arg_degrees == [1, 2]
c = adjoint(a, (u2, v2))
c_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(c)]
assert c_arg_degrees == [1, 2]
d = adjoint(b)
d_arg_degrees = [arg.ufl_element().degree() for arg in extract_arguments(d)]
assert d_arg_degrees == [2, 1]
def test_expr():
from ufl import triangle, FiniteElement, TestFunction, TrialFunction, Coefficient
element = FiniteElement("CG", triangle, 1)
v = TestFunction(element)
u = TrialFunction(element)
f = Coefficient(element)
g = Coefficient(element)
expr = (f+g)*u.dx(0)*(g-1)*v
return expr
def test_expr():
from ufl import triangle, FiniteElement, TestFunction, TrialFunction, Coefficient
element = FiniteElement("CG", triangle, 1)
v = TestFunction(element)
u = TrialFunction(element)
f = Coefficient(element)
g = Coefficient(element)
expr = (f + g) * u.dx(0) * (g - 1) * v
return expr
def test_lhs_rhs_simple():
"""Test taking lhs/rhs of DOLFINX specific forms (constants
without cell). """
mesh = RectangleMesh(
MPI.COMM_WORLD,
[numpy.array([0.0, 0.0, 0.0]),
numpy.array([2.0, 1.0, 0.0])], [3, 5], CellType.triangle)
V = FunctionSpace(mesh, "CG", 1)
f = 2.0
g = 3.0
v = TestFunction(V)
u = TrialFunction(V)
F = inner(g * grad(f * v), grad(u)) * dx + f * v * dx
a, L = system(F)
Fl = lhs(F)
Fr = rhs(F)
assert (Fr)
a0 = inner(grad(v), grad(u)) * dx
n = assemble(a).norm("frobenius") # noqa
nl = assemble(Fl).norm("frobenius") # noqa
n0 = 6.0 * assemble(a0).norm("frobenius") # noqa
assert round(n - n0, 7) == 0
assert round(n - nl, 7) == 0
def project(v, V, dx_, bcs=[], nm=None):
w = TestFunction(V)
Pv = TrialFunction(V)
a, L = as_ufl(0), as_ufl(0)
zerofnc = Function(V)
for n in range(len(dx_)):
# check if we have passed in a list of functions or a function
if isinstance(v, list):
fnc = v[n]
else:
fnc = v
if not isinstance(fnc, constantvalue.Zero):
a += inner(w, Pv) * dx_[n]
L += inner(w, fnc) * dx_[n]
else:
a += inner(w, Pv) * dx_[n]
L += inner(w, zerofnc) * dx_[n]
# solve linear system for projection
function = Function(V, name=nm)
lp = LinearProblem(a, L, bcs=bcs, u=function)
lp.solve()
return function
def test_krylov_solver_lu():
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = TrialFunction(V), TestFunction(V)
a = inner(u, v) * dx
L = inner(1.0, v) * dx
A = assemble_matrix(a)
A.assemble()
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
norm = 13.0
solver = PETSc.KSP().create(mesh.mpi_comm())
solver.setOptionsPrefix("test_lu_")
opts = PETSc.Options("test_lu_")
opts["ksp_type"] = "preonly"
opts["pc_type"] = "lu"
solver.setFromOptions()
x = A.createVecRight()
solver.setOperators(A)
solver.solve(b, x)
# *Tight* tolerance for LU solves
assert x.norm(PETSc.NormType.N2) == pytest.approx(norm, abs=1.0e-12)
def test_nullspace_check(mesh, degree):
V = VectorFunctionSpace(mesh, ('Lagrange', degree))
u, v = TrialFunction(V), TestFunction(V)
E, nu = 2.0e2, 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
def sigma(w, gdim):
return 2.0 * mu * ufl.sym(grad(w)) + lmbda * ufl.tr(
grad(w)) * ufl.Identity(gdim)
a = inner(sigma(u, mesh.geometry.dim), grad(v)) * dx
# Assemble matrix and create compatible vector
A = assemble_matrix(a)
A.assemble()
# Create null space basis and test
null_space = build_elastic_nullspace(V)
assert null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert null_space.in_nullspace(A, tol=1.0e-8)
# Create incorrect null space basis and test
null_space = build_broken_elastic_nullspace(V)
assert not null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert not null_space.in_nullspace(A, tol=1.0e-8)
def run_scalar_test(mesh, V, degree):
""" Manufactured Poisson problem, solving u = x[1]**p, where p is the
degree of the Lagrange function space.
"""
u, v = TrialFunction(V), TestFunction(V)
a = inner(grad(u), grad(v)) * dx
# Get quadrature degree for bilinear form integrand (ignores effect of non-affine map)
a = inner(grad(u), grad(v)) * dx(metadata={"quadrature_degree": -1})
a.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(a)
a = form(a)
# Source term
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
f = -div(grad(u_exact))
# Set quadrature degree for linear form integrand (ignores effect of non-affine map)
L = inner(f, v) * dx(metadata={"quadrature_degree": -1})
L.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(L)
L = form(L)
u_bc = Function(V)
u_bc.interpolate(lambda x: x[1]**degree)
# Create Dirichlet boundary condition
facetdim = mesh.topology.dim - 1
mesh.topology.create_connectivity(facetdim, mesh.topology.dim)
bndry_facets = np.where(
np.array(compute_boundary_facets(mesh.topology)) == 1)[0]
bdofs = locate_dofs_topological(V, facetdim, bndry_facets)
bc = dirichletbc(u_bc, bdofs)
b = assemble_vector(L)
apply_lifting(b, [a], bcs=[[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
a = form(a)
A = assemble_matrix(a, bcs=[bc])
A.assemble()
# Create LU linear solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
uh = Function(V)
solver.solve(b, uh.vector)
uh.x.scatter_forward()
M = (u_exact - uh)**2 * dx
M = form(M)
error = mesh.comm.allreduce(assemble_scalar(M), op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
def amg_solve(N, method):
# Elasticity parameters
E = 1.0e9
nu = 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
# Stress computation
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(
grad(v))) * Identity(2)
# Define problem
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = VectorFunctionSpace(mesh, 'Lagrange', 1)
u = TrialFunction(V)
v = TestFunction(V)
facetdim = mesh.topology.dim - 1
bndry_facets = locate_entities_boundary(
mesh, facetdim, lambda x: np.full(x.shape[1], True))
bdofs = locate_dofs_topological(V.sub(0), V, facetdim, bndry_facets)
bc = dirichletbc(PETSc.ScalarType(0), bdofs, V.sub(0))
# Forms
a, L = inner(sigma(u), grad(v)) * dx, dot(ufl.as_vector(
(1.0, 1.0)), v) * dx
# Assemble linear algebra objects
A = assemble_matrix(a, [bc])
A.assemble()
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
# Create solution function
u = Function(V)
# Create near null space basis and orthonormalize
null_space = build_nullspace(V, u.vector)
# Attached near-null space to matrix
A.set_near_nullspace(null_space)
# Test that basis is orthonormal
assert null_space.is_orthonormal()
# Create PETSC smoothed aggregation AMG preconditioner, and
# create CG solver
solver = PETSc.KSP().create(mesh.comm)
solver.setType("cg")
# Set matrix operator
solver.setOperators(A)
# Compute solution and return number of iterations
return solver.solve(b, u.vector)
def __init__(self, F, u, bc):
V = u.function_space
du = TrialFunction(V)
self.L = form(F)
self.a = form(derivative(F, u, du))
self.bc = bc
self._F, self._J = None, None
self.u = u
def __init__(self, F, u, bc):
super().__init__()
V = u.function_space
du = TrialFunction(V)
self.L = F
self.a = derivative(F, u, du)
self.bc = bc
self._F, self._J = None, None
def mass_dg(cell, degree):
m = Mesh(VectorElement('Q', cell, 1))
V = FunctionSpace(m, FiniteElement('DQ', cell, degree, variant='spectral'))
u = TrialFunction(V)
v = TestFunction(V)
# In this case, the estimated quadrature degree will give the
# correct number of quadrature points by luck.
return u * v * dx
def test_mini():
m = Mesh(VectorElement('CG', triangle, 1))
P1 = FiniteElement('Lagrange', triangle, 1)
B = FiniteElement("Bubble", triangle, 3)
V = FunctionSpace(m, VectorElement(P1 + B))
u = TrialFunction(V)
v = TestFunction(V)
a = inner(grad(u), grad(v)) * dx
count_flops(a)
def __init__(self, F, u, bc):
V = u.function_space
du = TrialFunction(V)
self.L = F
self.a = derivative(F, u, du)
self.a_comp = dolfinx.fem.Form(self.a)
self.bc = bc
self._F, self._J = None, None
self.u = u
def test_cell_error(cell, degree):
"""Test that tabulating the trace element deliberatly on the
cell triggers `gem.Failure` to raise the TraceError exception.
"""
trace_element = FiniteElement("HDiv Trace", cell, degree)
lambdar = TrialFunction(trace_element)
gammar = TestFunction(trace_element)
with pytest.raises(TraceError):
compile_form(lambdar * gammar * dx)
def test_compute_form_adjoint(self):
cell = triangle
element = FiniteElement('Lagrange', cell, 1)
u = TrialFunction(element)
v = TestFunction(element)
a = inner(grad(u), grad(v)) * dx
assert compute_form_adjoint(a) == conj(inner(grad(v), grad(u))) * dx
def elasticity(cell, degree):
m = Mesh(VectorElement('CG', cell, 1))
V = FunctionSpace(m, VectorElement('CG', cell, degree))
u = TrialFunction(V)
v = TestFunction(V)
def eps(u):
return 0.5 * (grad(u) + grad(u).T)
return inner(eps(u), eps(v)) * dx
def test_automatic_simplification(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
v = TestFunction(element)
u = TrialFunction(element)
assert inner(u, v) == u * conj(v)
assert dot(u, v) == u * v
assert outer(u, v) == conj(u) * v
def test_gradient_error(cell, degree):
"""Test that tabulating gradient evaluations of the trace
element triggers `gem.Failure` to raise the TraceError
exception.
"""
trace_element = FiniteElement("HDiv Trace", cell, degree)
lambdar = TrialFunction(trace_element)
gammar = TestFunction(trace_element)
with pytest.raises(TraceError):
compile_form(inner(grad(lambdar('+')), grad(gammar('+'))) * dS)
def test_plus_minus_matrix(cell_type, pm1, pm2):
"""Test that ('+') and ('-') match up with the correct DOFs for DG functions"""
results = []
spaces = []
orders = []
for count in range(3):
for agree in [True, False]:
# Two cell mesh with randomly numbered points
mesh, order = two_unit_cells(cell_type, agree, return_order=True)
V = FunctionSpace(mesh, ("DG", 1))
u, v = TrialFunction(V), TestFunction(V)
# Assemble matrices with combinations of + and - for a few
# different numberings
a = inner(u(pm1), v(pm2)) * dS
result = fem.assemble_matrix(a, [])
result.assemble()
spaces.append(V)
results.append(result)
orders.append(order)
# Check that the above matrices all have the same values, but
# permuted due to differently ordered dofs
dofmap0 = spaces[0].mesh.geometry.dofmap
for result, space in zip(results[1:], spaces[1:]):
# Get the data relating to two results
dofmap1 = space.mesh.geometry.dofmap
dof_order = []
# For each cell
for cell in range(2):
# For each point in cell 0 in the the first mesh
for dof0, point0 in zip(spaces[0].dofmap.cell_dofs(cell),
dofmap0.links(cell)):
# Find the point in the cell 0 in the second mesh
for dof1, point1 in zip(space.dofmap.cell_dofs(cell),
dofmap1.links(cell)):
if np.allclose(spaces[0].mesh.geometry.x[point0],
space.mesh.geometry.x[point1]):
break
else:
# If no matching point found, fail
assert False
dof_order.append((dof0, dof1))
# For all dof pairs, check that entries in the matrix agree
for a, b in dof_order:
for c, d in dof_order:
assert np.isclose(results[0][a, c], result[b, d])
def test_extract_elements_and_extract_unique_elements(forms):
b = forms[2]
integrals = b.integrals_by_type("cell")
integrand = integrals[0].integrand()
element1 = FiniteElement("CG", triangle, 1)
element2 = FiniteElement("CG", triangle, 1)
v = TestFunction(element1)
u = TrialFunction(element2)
a = u * v * dx
assert extract_elements(a) == (element1, element2)
assert extract_unique_elements(a) == (element1, )
def test_adjoint():
cell = triangle
V1 = FiniteElement("CG", cell, 1)
V2 = FiniteElement("CG", cell, 2)
u = TrialFunction(V1)
v = TestFunction(V2)
assert u.number() > v.number()
u2 = Argument(V1, 2)
v2 = Argument(V2, 3)
assert u2.number() < v2.number()
a = u * v * dx
a_arg_degrees = [
arg.ufl_element().degree() for arg in extract_arguments(a)
]
assert a_arg_degrees == [2, 1]
b = adjoint(a)
b_arg_degrees = [
arg.ufl_element().degree() for arg in extract_arguments(b)
]
assert b_arg_degrees == [1, 2]
c = adjoint(a, (u2, v2))
c_arg_degrees = [
arg.ufl_element().degree() for arg in extract_arguments(c)
]
assert c_arg_degrees == [1, 2]
d = adjoint(b)
d_arg_degrees = [
arg.ufl_element().degree() for arg in extract_arguments(d)
]
assert d_arg_degrees == [2, 1]
def test_extract_forms():
"""Test extraction on unique function spaces for rows and columns of
a block system"""
mesh = create_unit_square(MPI.COMM_WORLD, 32, 31)
V0 = FunctionSpace(mesh, ("Lagrange", 1))
V1 = FunctionSpace(mesh, ("Lagrange", 2))
V2 = V0.clone()
V3 = V1.clone()
v0, u0 = TestFunction(V0), TrialFunction(V0)
v1, u1 = TestFunction(V1), TrialFunction(V1)
v2, u2 = TestFunction(V2), TrialFunction(V2)
v3, u3 = TestFunction(V3), TrialFunction(V3)
a = form([[inner(u0, v0) * dx, inner(u1, v1) * dx],
[inner(u2, v2) * dx, inner(u3, v3) * dx]])
with pytest.raises(AssertionError):
extract_function_spaces(a, 0)
with pytest.raises(AssertionError):
extract_function_spaces(a, 1)
a = form([[inner(u0, v0) * dx, inner(u2, v1) * dx],
[inner(u0, v2) * dx, inner(u2, v2) * dx]])
with pytest.raises(AssertionError):
extract_function_spaces(a, 0)
Vc = extract_function_spaces(a, 1)
assert Vc[0] is V0._cpp_object
assert Vc[1] is V2._cpp_object
a = form([[inner(u0, v0) * dx, inner(u1, v0) * dx],
[inner(u2, v1) * dx, inner(u3, v1) * dx]])
Vr = extract_function_spaces(a, 0)
assert Vr[0] is V0._cpp_object
assert Vr[1] is V1._cpp_object
with pytest.raises(AssertionError):
extract_function_spaces(a, 1)
def test_plus_minus_matrix(cell_type, pm1, pm2):
"""Test that ('+') and ('-') match up with the correct DOFs for DG functions"""
results = []
spaces = []
orders = []
for count in range(3):
for agree in [True, False]:
mesh, order = two_unit_cells(cell_type, agree, return_order=True)
V = FunctionSpace(mesh, ("DG", 1))
u, v = TrialFunction(V), TestFunction(V)
a = inner(u(pm1), v(pm2)) * dS
result = fem.assemble_matrix(a, [])
result.assemble()
spaces.append(V)
results.append(result)
orders.append(order)
for i, j in combinations(zip(results, spaces, orders), 2):
dof_order = []
for cell in range(2):
for point in range(len(mesh.geometry.points)):
point_n = j[2][point]
cell_points = list(j[1].mesh.cells()[cell])
if point_n in cell_points:
point_n_in_cell = cell_points.index(point_n)
dofmap = j[1].dofmap.cell_dofs(cell)
j_dof_n = dofmap[point_n_in_cell]
else:
j_dof_n = None
point_n = i[2][point]
cell_points = list(i[1].mesh.cells()[cell])
if point_n in cell_points:
point_n_in_cell = cell_points.index(point_n)
dofmap = i[1].dofmap.cell_dofs(cell)
i_dof_n = dofmap[point_n_in_cell]
else:
i_dof_n = None
if i_dof_n is None:
assert j_dof_n is None
else:
dof_order.append((i_dof_n, j_dof_n))
for a, b in dof_order:
for c, d in dof_order:
assert np.isclose(i[0][a, c], j[0][b, d])
def test_expand_indices():
element = FiniteElement("Lagrange", triangle, 2)
v = TestFunction(element)
u = TrialFunction(element)
def evaluate(form):
return form.cell_integral()[0].integrand()((), {
v: 3,
u: 5
}) # TODO: How to define values of derivatives?
a = div(grad(v)) * u * dx
# a1 = evaluate(a)
a = expand_derivatives(a)
# a2 = evaluate(a)
a = expand_indices(a)
def __init__(self, mesh, k: int, omega, c, c0, lumped):
P = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), k)
self.V = FunctionSpace(mesh, P)
self.u, self.v = Function(self.V), Function(self.V)
self.g1 = Function(self.V)
self.g2 = Function(self.V)
self.omega = omega
self.c = c
self.c0 = c0
n = FacetNormal(mesh)
# Pieces for plane wave incident field
x = ufl.geometry.SpatialCoordinate(mesh)
cos_wave = ufl.cos(self.omega / self.c0 * x[0])
sin_wave = ufl.sin(self.omega / self.c0 * x[0])
plane_wave = self.g1 * cos_wave + self.g2 * sin_wave
dv, p = TrialFunction(self.V), TestFunction(self.V)
self.L1 = - inner(grad(self.u), grad(p)) * dx(degree=k) \
- (1 / self.c) * inner(self.v, p) * ds \
- (1 / self.c**2) * (-self.omega**2) * inner(plane_wave, p) * dx \
- inner(grad(plane_wave), grad(p)) * dx \
+ inner(dot(grad(plane_wave), n), p) * ds
# Vector to be re-used for assembly
self.b = None
# TODO: precompile/pre-process Form L
self.lumped = lumped
if self.lumped:
a = (1 / self.c**2) * p * dx(degree=k)
self.M = dolfinx.fem.assemble_vector(a)
self.M.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
else:
a = (1 / self.c**2) * inner(dv, p) * dx(degree=k)
M = dolfinx.fem.assemble_matrix(a)
M.assemble()
self.solver = PETSc.KSP().create(mesh.mpi_comm())
opts = PETSc.Options()
opts["ksp_type"] = "cg"
opts["ksp_rtol"] = 1.0e-8
self.solver.setFromOptions()
self.solver.setOperators(M)
def test_remove_complex_nodes(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
u = TrialFunction(element)
v = TestFunction(element)
f = Coefficient(element)
a = conj(v)
b = real(u)
c = imag(f)
d = conj(real(v))*imag(conj(u))
assert remove_complex_nodes(a) == v
assert remove_complex_nodes(b) == u
with pytest.raises(ufl.log.UFLException):
remove_complex_nodes(c)
with pytest.raises(ufl.log.UFLException):
remove_complex_nodes(d)
def test_apply_algebra_lowering_complex(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
v = TestFunction(element)
u = TrialFunction(element)
gv = grad(v)
gu = grad(u)
a = dot(gu, gv)
b = inner(gv, gu)
c = outer(gu, gv)
lowered_a = apply_algebra_lowering(a)
lowered_b = apply_algebra_lowering(b)
lowered_c = apply_algebra_lowering(c)
lowered_a_index = lowered_a.index()
lowered_b_index = lowered_b.index()
lowered_c_indices = lowered_c.indices()
assert lowered_a == gu[lowered_a_index] * gv[lowered_a_index]
assert lowered_b == gv[lowered_b_index] * conj(gu[lowered_b_index])
assert lowered_c == as_tensor(conj(gu[lowered_c_indices[0]]) * gv[lowered_c_indices[1]], (lowered_c_indices[0],) + (lowered_c_indices[1],))
def test_comparison_checker(self):
cell = triangle
element = FiniteElement("Lagrange", cell, 1)
u = TrialFunction(element)
v = TestFunction(element)
a = conditional(ge(abs(u), imag(v)), u, v)
b = conditional(le(sqrt(abs(u)), imag(v)), as_ufl(1), as_ufl(1j))
c = conditional(gt(abs(u), pow(imag(v), 0.5)), sin(u), cos(v))
d = conditional(lt(as_ufl(-1), as_ufl(1)), u, v)
e = max_value(as_ufl(0), real(u))
f = min_value(sin(u), cos(v))
g = min_value(sin(pow(u, 3)), cos(abs(v)))
assert do_comparison_check(a) == conditional(ge(real(abs(u)), real(imag(v))), u, v)
with pytest.raises(ComplexComparisonError):
b = do_comparison_check(b)
with pytest.raises(ComplexComparisonError):
c = do_comparison_check(c)
assert do_comparison_check(d) == conditional(lt(real(as_ufl(-1)), real(as_ufl(1))), u, v)
assert do_comparison_check(e) == max_value(real(as_ufl(0)), real(real(u)))
assert do_comparison_check(f) == min_value(real(sin(u)), real(cos(v)))
assert do_comparison_check(g) == min_value(real(sin(pow(u, 3))), real(cos(abs(v))))
#
# UFL is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# UFL is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with UFL. If not, see <http://www.gnu.org/licenses/>.
#
# Modified by Martin Sandve Alnæs, 2009
#
# Last changed: 2009-03-02
#
# The bilinear form a(v, u) and linear form L(v) for Poisson's equation.
from ufl import (Coefficient, FiniteElement, TestFunction, TrialFunction, dx,
grad, inner, triangle)
element = FiniteElement("Lagrange", triangle, 1)
u = TrialFunction(element)
v = TestFunction(element)
f = Coefficient(element)
a = inner(grad(v), grad(u)) * dx(degree=1)
L = v * f * dx(degree=2)
E = 1.0e9
nu = 0.0
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(grad(v))) * Identity(
len(v))
# Create function space
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = form(inner(sigma(u), grad(v)) * dx)
L = form(inner(f, v) * dx)
# Set up boundary condition on inner surface
bc = dirichletbc(
np.array([0, 0, 0], dtype=PETSc.ScalarType),
locate_dofs_geometrical(
V,
lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[1], 1.0))),
V)
# Assembly and solve
# ------------------
# ::
# grid = create.grid("ALUConform", dune.grid.cartesianDomain([0, 0], [1, 1], [89, 89]), dimgrid=2)
try:
grid = create.grid("ALUConform",
dune.grid.cartesianDomain([0, 0], [1, 1], [9, 9]),
dimgrid=2)
except:
grid = create.grid("Yasp",
dune.grid.cartesianDomain([0, 0], [1, 1], [9, 9]),
dimgrid=2)
d = 0.001
p = 1.7
uflSpace = Space((2, 2), 1)
u = TrialFunction(uflSpace)
v = TestFunction(uflSpace)
x = SpatialCoordinate(uflSpace.cell())
rhs = (x[0] + x[1]) * v[0]
a = (pow(d + inner(grad(u), grad(u)), (p - 2) / 2) * inner(grad(u), grad(v)) +
grad(u[0])[0] * v[0]) * dx + 10 * inner(u, v) * ds
b = rhs * dx + 10 * rhs * ds
model = create.model("integrands", grid, a == b)
def test(space):
if test_numpy:
numpySpace = create.space(space,
grid,
dimRange=1,
