def __init__(self, element):
nodes = element.dual.nodes
dim = element.ref_el.get_spatial_dimension()
if dim == 2:
ref_el = UFCQuadrilateral()
elif dim == 3:
ref_el = UFCHexahedron()
else:
raise ValueError("Illegal element dimension %s" % dim)
entity_ids = element.dual.entity_ids
flat_entity_ids = flatten_entities(entity_ids)
dual = DualSet(nodes, ref_el, flat_entity_ids)
super(FlattenedDimensions, self).__init__(ref_el, dual,
element.get_order(),
element.get_formdegree(),
element._mapping)
self.element = element
# Construct unflattening map for passing correct values to tabulate()
self.unflattening_map = compute_unflattening_map(
self.element.ref_el.get_topology())
def choosing_element(V, degree):
cell_geometry = V.mesh().ufl_cell()
if cell_geometry == quadrilateral:
T = UFCQuadrilateral()
raise ValueError(
"Point interpolation for quads implemented somewhere else.")
elif cell_geometry == triangle:
T = UFCTriangle()
elif cell_geometry == tetrahedron:
T = UFCTetrahedron()
else:
raise ValueError("Unrecognized cell geometry.")
if V.ufl_element().family() == "Kong-Mulder-Veldhuizen":
element = KMV(T, degree)
elif V.ufl_element().family() == "Lagrange":
element = CG(T, degree)
elif V.ufl_element().family() == "Discontinuous Lagrange":
element = DG(T, degree)
else:
raise ValueError("Function space not yet supported.")
return element
def extr_cell(request):
if request.param == "extr_interval":
return TensorProductCell(UFCInterval(), UFCInterval())
elif request.param == "extr_triangle":
return TensorProductCell(UFCTriangle(), UFCInterval())
elif request.param == "extr_quadrilateral":
return TensorProductCell(UFCQuadrilateral(), UFCInterval())
def test_serendipity_derivatives():
cell = UFCQuadrilateral()
S = Serendipity(cell, 2)
x = sympy.DeferredVector("X")
X, Y = x[0], x[1]
basis_functions = [
(1 - X) * (1 - Y),
Y * (1 - X),
X * (1 - Y),
X * Y,
Y * (1 - X) * (Y - 1),
X * Y * (Y - 1),
X * (1 - Y) * (X - 1),
X * Y * (X - 1),
]
points = [[0.5, 0.5], [0.25, 0.75]]
for alpha, actual in S.tabulate(2, points).items():
expect = list(
sympy.diff(basis, *zip([X, Y], alpha))
for basis in basis_functions)
expect = list(
[basis.subs(dict(zip([X, Y], point))) for point in points]
for basis in expect)
assert actual.shape == (8, 2)
assert np.allclose(np.asarray(expect, dtype=float),
actual.reshape(8, 2))
def cell(self):
dim = self.product.cell.get_spatial_dimension()
if dim == 2:
return UFCQuadrilateral()
elif dim == 3:
return UFCHexahedron()
else:
raise NotImplementedError("Cannot guess cell for spatial dimension %s" % dim)
def test_dual_tensor_versus_ufc():
K0 = UFCQuadrilateral()
ell = UFCInterval()
K1 = TensorProductCell(ell, ell)
S0 = Serendipity(K0, 2)
S1 = Serendipity(K1, 2)
# since both elements go through the flattened cell to produce the
# dual basis, they ought to do *exactly* the same calculations and
# hence form exactly the same nodes.
for i in range(S0.space_dimension()):
assert S0.dual.nodes[i].pt_dict == S1.dual.nodes[i].pt_dict
# Modified by David A. Ham ([email protected]), 2018 from FIAT import finite_element, polynomial_set, dual_set, functional from FIAT.reference_element import (Point, DefaultLine, UFCInterval, UFCQuadrilateral, UFCHexahedron, UFCTriangle, UFCTetrahedron, make_affine_mapping, flatten_reference_cube) from FIAT.P0 import P0Dual import numpy as np hypercube_simplex_map = { Point(): Point(), DefaultLine(): DefaultLine(), UFCInterval(): UFCInterval(), UFCQuadrilateral(): UFCTriangle(), UFCHexahedron(): UFCTetrahedron() } class DPC0(finite_element.CiarletElement): def __init__(self, ref_el): flat_el = flatten_reference_cube(ref_el) poly_set = polynomial_set.ONPolynomialSet( hypercube_simplex_map[flat_el], 0) dual = P0Dual(ref_el) degree = 0 formdegree = ref_el.get_spatial_dimension() # n-form super(DPC0, self).__init__(poly_set=poly_set, dual=dual, order=degree,
def extr_quadrilateral():
"""Extruded quadrilateral = quadrilateral x interval"""
return TensorProductCell(UFCQuadrilateral(), UFCInterval())
def quadrilateral():
return UFCQuadrilateral()
def cell(self):
return UFCQuadrilateral()
import pytest
import numpy as np
from FIAT.reference_element import UFCInterval, UFCTriangle, UFCTetrahedron
from FIAT.reference_element import UFCQuadrilateral, TensorProductCell
from tsfc.fem import make_cell_facet_jacobian
interval = UFCInterval()
triangle = UFCTriangle()
quadrilateral = UFCQuadrilateral()
tetrahedron = UFCTetrahedron()
interval_x_interval = TensorProductCell(interval, interval)
triangle_x_interval = TensorProductCell(triangle, interval)
quadrilateral_x_interval = TensorProductCell(quadrilateral, interval)
@pytest.mark.parametrize(
('cell', 'cell_facet_jacobian'),
[(interval, [[], []]), (triangle, [[-1, 1], [0, 1], [1, 0]]),
(quadrilateral, [[0, 1], [0, 1], [1, 0], [1, 0]]),
(tetrahedron, [[-1, -1, 1, 0, 0, 1], [0, 0, 1, 0, 0, 1],
[1, 0, 0, 0, 0, 1], [1, 0, 0, 1, 0, 0]])])
def test_cell_facet_jacobian(cell, cell_facet_jacobian):
facet_dim = cell.get_spatial_dimension() - 1
for facet_number in range(len(cell.get_topology()[facet_dim])):
actual = make_cell_facet_jacobian(cell, facet_dim, facet_number)
expected = np.reshape(cell_facet_jacobian[facet_number], actual.shape)
assert np.allclose(expected, actual)
