def xtest_third_order_tri():
# *---*---*---* 3--11--10--2
# | \ | | \ |
# * * * * 8 7 15 13
# | \ | | \ |
# * * * * 9 14 6 12
# | \ | | \ |
# *---*---*---* 0--4---5---1
for H in (1.0, 2.0):
for Z in (0.0, 0.5):
L = 1
points = np.array([
[0, 0, 0],
[L, 0, 0],
[L, H, Z],
[0, H, Z], # 0, 1, 2, 3
[L / 3, 0, 0],
[2 * L / 3, 0, 0], # 4, 5
[2 * L / 3, H / 3, 0],
[L / 3, 2 * H / 3, 0], # 6, 7
[0, 2 * H / 3, 0],
[0, H / 3, 0], # 8, 9
[2 * L / 3, H, Z],
[L / 3, H, Z], # 10, 11
[L, H / 3, 0],
[L, 2 * H / 3, 0], # 12, 13
[L / 3, H / 3, 0], # 14
[2 * L / 3, 2 * H / 3, 0]
]) # 15
cells = np.array([[0, 1, 3, 4, 5, 6, 7, 8, 9, 14],
[1, 2, 3, 12, 13, 10, 11, 7, 6, 15]])
cells = permute_cell_ordering(
cells,
permutation_vtk_to_dolfin(CellType.triangle, cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD,
CellType.triangle,
points,
cells, [],
degree=3)
def e2(x):
return x[2] + x[0] * x[1]
degree = mesh.geometry.dofmap_layout().degree()
# Interpolate function
V = FunctionSpace(mesh, ("CG", degree))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(u * dx(metadata={"quadrature_degree": 40}))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 9, 8, 3]
ref = sympy_scipy(points, nodes, L, H)
assert ref == pytest.approx(intu, rel=1e-6)
def __init__(self,
mesh: Mesh,
element: typing.Union[ufl.FiniteElementBase, ElementMetaData],
cppV: typing.Optional[_cpp.fem.FunctionSpace] = None,
form_compiler_params: dict = {},
jit_params: dict = {}):
"""Create a finite element function space."""
# Create function space from a UFL element and existing cpp
# FunctionSpace
if cppV is not None:
assert mesh is None
ufl_domain = cppV.mesh.ufl_domain()
super().__init__(ufl_domain, element)
self._cpp_object = cppV
return
# Initialise the ufl.FunctionSpace
if isinstance(element, ufl.FiniteElementBase):
super().__init__(mesh.ufl_domain(), element)
else:
e = ElementMetaData(*element)
ufl_element = ufl.FiniteElement(e.family,
mesh.ufl_cell(),
e.degree,
form_degree=e.form_degree)
super().__init__(mesh.ufl_domain(), ufl_element)
# Compile dofmap and element and create DOLFIN objects
(self._ufcx_element, self._ufcx_dofmap), module, code = jit.ffcx_jit(
mesh.comm,
self.ufl_element(),
form_compiler_params=form_compiler_params,
jit_params=jit_params)
ffi = cffi.FFI()
cpp_element = _cpp.fem.FiniteElement(
ffi.cast("uintptr_t", ffi.addressof(self._ufcx_element)))
cpp_dofmap = _cpp.fem.create_dofmap(
mesh.comm, ffi.cast("uintptr_t", ffi.addressof(self._ufcx_dofmap)),
mesh.topology, cpp_element)
# Initialize the cpp.FunctionSpace
self._cpp_object = _cpp.fem.FunctionSpace(mesh, cpp_element,
cpp_dofmap)
def TensorFunctionSpace(mesh: Mesh,
element: ElementMetaData,
shape=None,
symmetry: typing.Optional[bool] = None,
restriction=None) -> FunctionSpace:
"""Create tensor finite element (composition of scalar elements) function space."""
e = ElementMetaData(*element)
ufl_element = ufl.TensorElement(e.family, mesh.ufl_cell(), e.degree, shape,
symmetry)
return FunctionSpace(mesh, ufl_element)
def test_second_order_tri():
# Test second order mesh by computing volume of two cells
# *-----*-----* 3----6-----2
# | \ | | \ |
# | \ | | \ |
# * * * 7 8 5
# | \ | | \ |
# | \ | | \ |
# *-----*-----* 0----4-----1
for H in (1.0, 2.0):
for Z in (0.0, 0.5):
L = 1
points = np.array([[0, 0, 0], [L, 0, 0], [L, H, Z], [0, H, Z],
[L / 2, 0, 0], [L, H / 2, 0], [L / 2, H, Z],
[0, H / 2, 0], [L / 2, H / 2, 0]])
cells = np.array([[0, 1, 3, 4, 8, 7], [1, 2, 3, 5, 6, 8]])
cells = permute_cell_ordering(
cells,
permutation_vtk_to_dolfin(CellType.triangle, cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD,
CellType.triangle,
points,
cells, [],
degree=2)
def e2(x):
return x[2] + x[0] * x[1]
# Interpolate function
V = FunctionSpace(mesh, ("CG", 2))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(
u * dx(mesh, metadata={"quadrature_degree": 20}))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 3, 7]
ref = sympy_scipy(points, nodes, L, H)
assert ref == pytest.approx(intu, rel=1e-6)
def test_second_order_quad(L, H, Z):
""" Test by comparing integration of z+x*y against sympy/scipy
integration of a quad element. Z>0 implies curved element.
*-----* 3--6--2
| | | |
| | 7 8 5
| | | |
*-----* 0--4--1
"""
points = np.array([[0, 0, 0], [L, 0, 0], [L, H, Z], [0, H, Z],
[L / 2, 0, 0], [L, H / 2, 0], [L / 2, H, Z],
[0, H / 2, 0], [L / 2, H / 2, 0], [2 * L, 0, 0],
[2 * L, H, Z]])
cells = np.array([[0, 1, 2, 3, 4, 5, 6, 7, 8]])
cells = permute_cell_ordering(
cells, permutation_vtk_to_dolfin(CellType.quadrilateral,
cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD,
CellType.quadrilateral,
points,
cells, [],
degree=2)
def e2(x):
return x[2] + x[0] * x[1]
# Interpolate function
V = FunctionSpace(mesh, ("CG", 2))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(u * dx(mesh))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 3, 7]
ref = sympy_scipy(points, nodes, L, H)
assert ref == pytest.approx(intu, rel=1e-6)
def test_gmsh_input_quad(order):
pygmsh = pytest.importorskip("pygmsh")
# Parameterize test if gmsh gets wider support
R = 1
res = 0.2 if order == 2 else 0.2
algorithm = 2 if order == 2 else 5
element = "quad{0:d}".format(int((order + 1)**2))
geo = pygmsh.opencascade.Geometry()
geo.add_raw_code("Mesh.ElementOrder={0:d};".format(order))
geo.add_ball([0, 0, 0], R, char_length=res)
geo.add_raw_code("Recombine Surface {1};")
geo.add_raw_code("Mesh.Algorithm = {0:d};".format(algorithm))
msh = pygmsh.generate_mesh(geo, verbose=True, dim=2)
if order > 2:
# Quads order > 3 have a gmsh specific ordering, and has to be
# re-mapped
msh_to_dolfin = np.array(
[0, 3, 11, 10, 1, 2, 6, 7, 4, 9, 12, 15, 5, 8, 13, 14])
cells = np.zeros(msh.cells_dict[element].shape)
for i in range(len(cells)):
for j in range(len(msh_to_dolfin)):
cells[i, j] = msh.cells_dict[element][i, msh_to_dolfin[j]]
else:
# XDMF does not support higher order quads
cells = msh.cells_dict[
element][:,
perm_vtk(CellType.quadrilateral, msh.cells_dict[element].
shape[1])]
mesh = Mesh(MPI.COMM_WORLD,
CellType.quadrilateral,
msh.points,
cells, [],
degree=order)
surface = assemble_scalar(1 * dx(mesh))
assert mesh.mpi_comm().allreduce(surface, op=MPI.SUM) == pytest.approx(
4 * np.pi * R * R, rel=1e-5)
def VectorFunctionSpace(mesh: Mesh,
element: ElementMetaData,
dim=None,
restriction=None) -> FunctionSpace:
"""Create vector finite element (composition of scalar elements) function space."""
e = ElementMetaData(*element)
ufl_element = ufl.VectorElement(e.family,
mesh.ufl_cell(),
e.degree,
form_degree=e.form_degree,
dim=dim)
return FunctionSpace(mesh, ufl_element)
def perform_test(points, cells):
mesh = Mesh(MPI.COMM_WORLD, CellType.tetrahedron, points,
np.array(cells), [])
V = FunctionSpace(mesh, (space_type, order))
f = Function(V)
output = []
for dof in range(len(f.vector[:])):
f.vector[:] = np.zeros(len(f.vector[:]))
f.vector[dof] = 1
points = np.array([[1 / 3, 1 / 3, 1 / 3], [1 / 3, 1 / 3, 1 / 3]])
cells = np.array([0, 1])
result = f.eval(points, cells)
normal = np.array([1., 1., 1.])
output.append(result.dot(normal))
return output
def read_mesh(self,
ghost_mode=GhostMode.shared_facet,
name="mesh",
xpath="/Xdmf/Domain") -> Mesh:
"""Read mesh data from file"""
cell_shape, cell_degree = super().read_cell_type(name, xpath)
cells = super().read_topology_data(name, xpath)
x = super().read_geometry_data(name, xpath)
# Construct the geometry map
cell = ufl.Cell(cell_shape.name, geometric_dimension=x.shape[1])
# Build the mesh
cmap = _cpp.fem.CoordinateElement(cell_shape, cell_degree)
mesh = _cpp.mesh.create_mesh(self.comm(),
_cpp.graph.AdjacencyList_int64(cells),
cmap, x, ghost_mode,
_cpp.mesh.create_cell_partitioner())
mesh.name = name
domain = ufl.Mesh(ufl.VectorElement("Lagrange", cell, cell_degree))
return Mesh.from_cpp(mesh, domain)
def xtest_fourth_order_quad(L, H, Z):
"""Test by comparing integration of z+x*y against sympy/scipy integration
of a quad element. Z>0 implies curved element.
*---------* 20-21-22-23-24-41--42--43--44
| | | | |
| | 15 16 17 18 19 37 38 39 40
| | | | |
| | 10 11 12 13 14 33 34 35 36
| | | | |
| | 5 6 7 8 9 29 30 31 32
| | | | |
*---------* 0--1--2--3--4--25--26--27--28
"""
points = np.array([
[0, 0, 0],
[L / 4, 0, 0],
[L / 2, 0, 0], # 0 1 2
[3 * L / 4, 0, 0],
[L, 0, 0], # 3 4
[0, H / 4, -Z / 3],
[L / 4, H / 4, -Z / 3],
[L / 2, H / 4, -Z / 3], # 5 6 7
[3 * L / 4, H / 4, -Z / 3],
[L, H / 4, -Z / 3], # 8 9
[0, H / 2, 0],
[L / 4, H / 2, 0],
[L / 2, H / 2, 0], # 10 11 12
[3 * L / 4, H / 2, 0],
[L, H / 2, 0], # 13 14
[0, (3 / 4) * H, 0],
[L / 4, (3 / 4) * H, 0], # 15 16
[L / 2, (3 / 4) * H, 0],
[3 * L / 4, (3 / 4) * H, 0], # 17 18
[L, (3 / 4) * H, 0],
[0, H, Z],
[L / 4, H, Z], # 19 20 21
[L / 2, H, Z],
[3 * L / 4, H, Z],
[L, H, Z], # 22 23 24
[(5 / 4) * L, 0, 0],
[(6 / 4) * L, 0, 0], # 25 26
[(7 / 4) * L, 0, 0],
[2 * L, 0, 0], # 27 28
[(5 / 4) * L, H / 4, -Z / 3],
[(6 / 4) * L, H / 4, -Z / 3], # 29 30
[(7 / 4) * L, H / 4, -Z / 3],
[2 * L, H / 4, -Z / 3], # 31 32
[(5 / 4) * L, H / 2, 0],
[(6 / 4) * L, H / 2, 0], # 33 34
[(7 / 4) * L, H / 2, 0],
[2 * L, H / 2, 0], # 35 36
[(5 / 4) * L, 3 / 4 * H, 0], # 37
[(6 / 4) * L, 3 / 4 * H, 0], # 38
[(7 / 4) * L, 3 / 4 * H, 0],
[2 * L, 3 / 4 * H, 0], # 39 40
[(5 / 4) * L, H, Z],
[(6 / 4) * L, H, Z], # 41 42
[(7 / 4) * L, H, Z],
[2 * L, H, Z]
]) # 43 44
# VTK ordering
cells = np.array([[
0, 4, 24, 20, 1, 2, 3, 9, 14, 19, 21, 22, 23, 5, 10, 15, 6, 7, 8, 11,
12, 13, 16, 17, 18
],
[
4, 28, 44, 24, 25, 26, 27, 32, 36, 40, 41, 42, 43, 9,
14, 19, 29, 30, 31, 33, 34, 35, 37, 38, 39
]])
cells = permute_cell_ordering(
cells, permutation_vtk_to_dolfin(CellType.quadrilateral,
cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD, CellType.quadrilateral, points, cells, [],
GhostMode.none)
def e2(x):
return x[2] + x[0] * x[1]
V = FunctionSpace(mesh, ("CG", 4))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(u * dx(mesh))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 5, 10, 15, 20]
ref = sympy_scipy(points, nodes, 2 * L, H)
assert ref == pytest.approx(intu, rel=1e-5)
def xtest_third_order_quad(L, H, Z):
"""Test by comparing integration of z+x*y against sympy/scipy integration
of a quad element. Z>0 implies curved element.
*---------* 3--8--9--2-22-23-17
| | | | |
| | 11 14 15 7 26 27 21
| | | | |
| | 10 12 13 6 24 25 20
| | | | |
*---------* 0--4--5--1-18-19-16
"""
points = np.array([
[0, 0, 0],
[L, 0, 0],
[L, H, Z],
[0, H, Z], # 0 1 2 3
[L / 3, 0, 0],
[2 * L / 3, 0, 0], # 4 5
[L, H / 3, 0],
[L, 2 * H / 3, 0], # 6 7
[L / 3, H, Z],
[2 * L / 3, H, Z], # 8 9
[0, H / 3, 0],
[0, 2 * H / 3, 0], # 10 11
[L / 3, H / 3, 0],
[2 * L / 3, H / 3, 0], # 12 13
[L / 3, 2 * H / 3, 0],
[2 * L / 3, 2 * H / 3, 0], # 14 15
[2 * L, 0, 0],
[2 * L, H, Z], # 16 17
[4 * L / 3, 0, 0],
[5 * L / 3, 0, 0], # 18 19
[2 * L, H / 3, 0],
[2 * L, 2 * H / 3, 0], # 20 21
[4 * L / 3, H, Z],
[5 * L / 3, H, Z], # 22 23
[4 * L / 3, H / 3, 0],
[5 * L / 3, H / 3, 0], # 24 25
[4 * L / 3, 2 * H / 3, 0],
[5 * L / 3, 2 * H / 3, 0]
]) # 26 27
# Change to multiple cells when matthews dof-maps work for quads
cells = np.array(
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
[1, 16, 17, 2, 18, 19, 20, 21, 22, 23, 6, 7, 24, 25, 26, 27]])
cells = permute_cell_ordering(
cells, permutation_vtk_to_dolfin(CellType.quadrilateral,
cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD, CellType.quadrilateral, points, cells, [])
def e2(x):
return x[2] + x[0] * x[1]
# Interpolate function
V = FunctionSpace(mesh, ("CG", 3))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(u * dx(mesh))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 3, 10, 11]
ref = sympy_scipy(points, nodes, 2 * L, H)
assert ref == pytest.approx(intu, rel=1e-6)
def test_nth_order_triangle(order):
num_nodes = (order + 1) * (order + 2) / 2
cells = np.array([range(int(num_nodes))])
cells = permute_cell_ordering(
cells, permutation_vtk_to_dolfin(CellType.triangle, cells.shape[1]))
if order == 1:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000]])
elif order == 2:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.50000, 0.50000, -0.25000],
[0.00000, 0.50000, -0.25000]])
elif order == 3:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.33333, 0.00000, 0.00000],
[0.66667, 0.00000, 0.00000],
[0.66667, 0.33333, -0.11111],
[0.33333, 0.66667, 0.11111],
[0.00000, 0.66667, 0.11111],
[0.00000, 0.33333, -0.11111],
[0.33333, 0.33333, -0.11111]])
elif order == 4:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.25000, 0.00000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.75000, 0.00000, 0.00000],
[0.75000, 0.25000, -0.06250],
[0.50000, 0.50000, 0.06250],
[0.25000, 0.75000, -0.06250],
[0.00000, 0.75000, -0.06250],
[0.00000, 0.50000, 0.06250],
[0.00000, 0.25000, -0.06250],
[0.25000, 0.25000, -0.06250],
[0.50000, 0.25000, -0.06250],
[0.25000, 0.50000, 0.06250]])
elif order == 5:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.20000, 0.00000, 0.00000],
[0.40000, 0.00000, 0.00000],
[0.60000, 0.00000, 0.00000],
[0.80000, 0.00000, 0.00000],
[0.80000, 0.20000, -0.04000],
[0.60000, 0.40000, 0.04000],
[0.40000, 0.60000, -0.04000],
[0.20000, 0.80000, 0.04000],
[0.00000, 0.80000, 0.04000],
[0.00000, 0.60000, -0.04000],
[0.00000, 0.40000, 0.04000],
[0.00000, 0.20000, -0.04000],
[0.20000, 0.20000, -0.04000],
[0.60000, 0.20000, -0.04000],
[0.20000, 0.60000, -0.04000],
[0.40000, 0.20000, -0.04000],
[0.40000, 0.40000, 0.04000],
[0.20000, 0.40000, 0.04000]])
elif order == 6:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.16667, 0.00000, 0.00000],
[0.33333, 0.00000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.66667, 0.00000, 0.00000],
[0.83333, 0.00000, 0.00000],
[0.83333, 0.16667, -0.00463],
[0.66667, 0.33333, 0.00463],
[0.50000, 0.50000, -0.00463],
[0.33333, 0.66667, 0.00463],
[0.16667, 0.83333, -0.00463],
[0.00000, 0.83333, -0.00463],
[0.00000, 0.66667, 0.00463],
[0.00000, 0.50000, -0.00463],
[0.00000, 0.33333, 0.00463],
[0.00000, 0.16667, -0.00463],
[0.16667, 0.16667, -0.00463],
[0.66667, 0.16667, -0.00463],
[0.16667, 0.66667, 0.00463],
[0.33333, 0.16667, -0.00463],
[0.50000, 0.16667, -0.00463],
[0.50000, 0.33333, 0.00463],
[0.33333, 0.50000, -0.00463],
[0.16667, 0.50000, -0.00463],
[0.16667, 0.33333, 0.00463],
[0.33333, 0.33333, 0.00463]])
elif order == 7:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.14286, 0.00000, 0.00000],
[0.28571, 0.00000, 0.00000],
[0.42857, 0.00000, 0.00000],
[0.57143, 0.00000, 0.00000],
[0.71429, 0.00000, 0.00000],
[0.85714, 0.00000, 0.00000],
[0.85714, 0.14286, -0.02041],
[0.71429, 0.28571, 0.02041],
[0.57143, 0.42857, -0.02041],
[0.42857, 0.57143, 0.02041],
[0.28571, 0.71429, -0.02041],
[0.14286, 0.85714, 0.02041],
[0.00000, 0.85714, 0.02041],
[0.00000, 0.71429, -0.02041],
[0.00000, 0.57143, 0.02041],
[0.00000, 0.42857, -0.02041],
[0.00000, 0.28571, 0.02041],
[0.00000, 0.14286, -0.02041],
[0.14286, 0.14286, -0.02041],
[0.71429, 0.14286, -0.02041],
[0.14286, 0.71429, -0.02041],
[0.28571, 0.14286, -0.02041],
[0.42857, 0.14286, -0.02041],
[0.57143, 0.14286, -0.02041],
[0.57143, 0.28571, 0.02041],
[0.42857, 0.42857, -0.02041],
[0.28571, 0.57143, 0.02041],
[0.14286, 0.57143, 0.02041],
[0.14286, 0.42857, -0.02041],
[0.14286, 0.28571, 0.02041],
[0.28571, 0.28571, 0.02041],
[0.42857, 0.28571, 0.02041],
[0.28571, 0.42857, -0.02041]])
# Higher order tests are too slow
elif order == 8:
points = np.array([[0.00000, 0.00000, 0.00000],
[1.00000, 0.00000, 0.00000],
[0.00000, 1.00000, 0.00000],
[0.12500, 0.00000, 0.00000],
[0.25000, 0.00000, 0.00000],
[0.37500, 0.00000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.62500, 0.00000, 0.00000],
[0.75000, 0.00000, 0.00000],
[0.87500, 0.00000, 0.00000],
[0.87500, 0.12500, -0.00195],
[0.75000, 0.25000, 0.00195],
[0.62500, 0.37500, -0.00195],
[0.50000, 0.50000, 0.00195],
[0.37500, 0.62500, -0.00195],
[0.25000, 0.75000, 0.00195],
[0.12500, 0.87500, -0.00195],
[0.00000, 0.87500, -0.00195],
[0.00000, 0.75000, 0.00195],
[0.00000, 0.62500, -0.00195],
[0.00000, 0.50000, 0.00195],
[0.00000, 0.37500, -0.00195],
[0.00000, 0.25000, 0.00195],
[0.00000, 0.12500, -0.00195],
[0.12500, 0.12500, -0.00195],
[0.75000, 0.12500, -0.00195],
[0.12500, 0.75000, 0.00195],
[0.25000, 0.12500, -0.00195],
[0.37500, 0.12500, -0.00195],
[0.50000, 0.12500, -0.00195],
[0.62500, 0.12500, -0.00195],
[0.62500, 0.25000, 0.00195],
[0.50000, 0.37500, -0.00195],
[0.37500, 0.50000, 0.00195],
[0.25000, 0.62500, -0.00195],
[0.12500, 0.62500, -0.00195],
[0.12500, 0.50000, 0.00195],
[0.12500, 0.37500, -0.00195],
[0.12500, 0.25000, 0.00195],
[0.25000, 0.25000, 0.00195],
[0.50000, 0.25000, 0.00195],
[0.25000, 0.50000, 0.00195],
[0.37500, 0.25000, 0.00195],
[0.37500, 0.37500, -0.00195],
[0.25000, 0.37500, -0.00195]])
mesh = Mesh(MPI.COMM_WORLD, CellType.triangle, points, cells, [])
# Find nodes corresponding to y axis
nodes = []
for j in range(points.shape[0]):
if np.isclose(points[j][0], 0):
nodes.append(j)
def e2(x):
return x[2] + x[0] * x[1]
# For solution to be in functionspace
V = FunctionSpace(mesh, ("CG", max(2, order)))
u = Function(V)
u.interpolate(e2)
quad_order = 30
intu = assemble_scalar(u * dx(metadata={"quadrature_degree": quad_order}))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
ref = scipy_one_cell(points, nodes)
assert ref == pytest.approx(intu, rel=3e-3)
def xtest_fourth_order_tri():
L = 1
# *--*--*--*--* 3-21-20-19--2
# | \ | | \ |
# * * * * * 10 9 24 23 18
# | \ | | \ |
# * * * * * 11 15 8 22 17
# | \ | | \ |
# * * * * * 12 13 14 7 16
# | \ | | \ |
# *--*--*--*--* 0--4--5--6--1
for H in (1.0, 2.0):
for Z in (0.0, 0.5):
points = np.array([
[0, 0, 0],
[L, 0, 0],
[L, H, Z],
[0, H, Z], # 0, 1, 2, 3
[L / 4, 0, 0],
[L / 2, 0, 0],
[3 * L / 4, 0, 0], # 4, 5, 6
[3 / 4 * L, H / 4, Z / 2],
[L / 2, H / 2, 0], # 7, 8
[L / 4, 3 * H / 4, 0],
[0, 3 * H / 4, 0], # 9, 10
[0, H / 2, 0],
[0, H / 4, Z / 2], # 11, 12
[L / 4, H / 4, Z / 2],
[L / 2, H / 4, Z / 2],
[L / 4, H / 2, 0], # 13, 14, 15
[L, H / 4, Z / 2],
[L, H / 2, 0],
[L, 3 * H / 4, 0], # 16, 17, 18
[3 * L / 4, H, Z],
[L / 2, H, Z],
[L / 4, H, Z], # 19, 20, 21
[3 * L / 4, H / 2, 0],
[3 * L / 4, 3 * H / 4, 0], # 22, 23
[L / 2, 3 * H / 4, 0]
] # 24
)
cells = np.array(
[[0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
[1, 2, 3, 16, 17, 18, 19, 20, 21, 9, 8, 7, 22, 23, 24]])
cells = permute_cell_ordering(
cells,
permutation_vtk_to_dolfin(CellType.triangle, cells.shape[1]))
mesh = Mesh(MPI.COMM_WORLD,
CellType.triangle,
points,
cells, [],
degree=4)
def e2(x):
return x[2] + x[0] * x[1]
degree = mesh.geometry.degree()
# Interpolate function
V = FunctionSpace(mesh, ("CG", degree))
u = Function(V)
u.interpolate(e2)
intu = assemble_scalar(u * dx(metadata={"quadrature_degree": 50}))
intu = mesh.mpi_comm().allreduce(intu, op=MPI.SUM)
nodes = [0, 3, 10, 11, 12]
ref = sympy_scipy(points, nodes, L, H)
assert ref == pytest.approx(intu, rel=1e-4)
