def construct_dg_element(ref_el, degree):
"""Constructs a discontinuous galerkin element of a given degree
on a particular reference cell.
"""
if ref_el.get_shape() in [LINE, TRIANGLE]:
dg_element = DiscontinuousLagrange(ref_el, degree)
# Quadrilateral facets could be on a FiredrakeQuadrilateral.
# In this case, we treat this as an interval x interval cell:
elif ref_el.get_shape() == QUADRILATERAL:
dg_a = DiscontinuousLagrange(ufc_simplex(1), degree)
dg_b = DiscontinuousLagrange(ufc_simplex(1), degree)
dg_element = TensorProductElement(dg_a, dg_b)
# This handles the more general case for facets:
elif ref_el.get_shape() == TENSORPRODUCT:
assert len(degree) == len(ref_el.cells), (
"Must provide the same number of degrees as the number "
"of cells that make up the tensor product cell."
)
sub_elements = [construct_dg_element(c, d)
for c, d in zip(ref_el.cells, degree)
if c.get_shape() != POINT]
if len(sub_elements) > 1:
dg_element = TensorProductElement(*sub_elements)
else:
dg_element, = sub_elements
else:
raise NotImplementedError(
"Reference cells of type %s not currently supported" % type(ref_el)
)
return dg_element
def test_TFE_2Dx1D_vector_quad_hdiv():
T = UFCInterval()
P1 = Lagrange(T, 1)
P0 = DiscontinuousLagrange(T, 0)
P1_DG = DiscontinuousLagrange(T, 1)
P1P0 = Hdiv(TensorProductElement(P1, P0))
P0P1 = Hdiv(TensorProductElement(P0, P1))
horiz_elt = EnrichedElement(P1P0, P0P1)
elt = Hdiv(TensorProductElement(horiz_elt, P1_DG))
assert elt.value_shape() == (3, )
tab = elt.tabulate(1, [(0.1, 0.2, 0.3)])
tA = P1.tabulate(1, [(0.1, )])
tB = P0.tabulate(1, [(0.2, )])
tC = P0.tabulate(1, [(0.1, )])
tD = P1.tabulate(1, [(0.2, )])
tE = P1_DG.tabulate(1, [(0.3, )])
for da, db, dc in [[(0, ), (0, ), (0, )], [(1, ), (0, ), (0, )],
[(0, ), (1, ), (0, )], [(0, ), (0, ), (1, )]]:
dd = da + db + dc
assert np.isclose(tab[dd][0][0][0],
-tA[da][0][0] * tB[db][0][0] * tE[dc][0][0])
assert np.isclose(tab[dd][1][0][0],
-tA[da][0][0] * tB[db][0][0] * tE[dc][1][0])
assert np.isclose(tab[dd][2][0][0],
-tA[da][1][0] * tB[db][0][0] * tE[dc][0][0])
assert np.isclose(tab[dd][3][0][0],
-tA[da][1][0] * tB[db][0][0] * tE[dc][1][0])
assert tab[dd][4][0][0] == 0.0
assert tab[dd][5][0][0] == 0.0
assert tab[dd][6][0][0] == 0.0
assert tab[dd][7][0][0] == 0.0
assert tab[dd][0][1][0] == 0.0
assert tab[dd][1][1][0] == 0.0
assert tab[dd][2][1][0] == 0.0
assert tab[dd][3][1][0] == 0.0
assert np.isclose(tab[dd][4][1][0],
tC[da][0][0] * tD[db][0][0] * tE[dc][0][0])
assert np.isclose(tab[dd][5][1][0],
tC[da][0][0] * tD[db][0][0] * tE[dc][1][0])
assert np.isclose(tab[dd][6][1][0],
tC[da][0][0] * tD[db][1][0] * tE[dc][0][0])
assert np.isclose(tab[dd][7][1][0],
tC[da][0][0] * tD[db][1][0] * tE[dc][1][0])
assert tab[dd][0][2][0] == 0.0
assert tab[dd][1][2][0] == 0.0
assert tab[dd][2][2][0] == 0.0
assert tab[dd][3][2][0] == 0.0
assert tab[dd][4][2][0] == 0.0
assert tab[dd][5][2][0] == 0.0
assert tab[dd][6][2][0] == 0.0
assert tab[dd][7][2][0] == 0.0
def test_TFE_2Dx1D_vector_triangle_hdiv():
S = UFCTriangle()
T = UFCInterval()
RT1 = RaviartThomas(S, 1)
P1_DG = DiscontinuousLagrange(T, 1)
elt = Hdiv(TensorProductElement(RT1, P1_DG))
assert elt.value_shape() == (3, )
tab = elt.tabulate(1, [(0.1, 0.2, 0.3)])
tabA = RT1.tabulate(1, [(0.1, 0.2)])
tabB = P1_DG.tabulate(1, [(0.3, )])
for da, db in [[(0, 0), (0, )], [(1, 0), (0, )], [(0, 1), (0, )],
[(0, 0), (1, )]]:
dc = da + db
assert np.isclose(tab[dc][0][0][0], tabA[da][0][0][0] * tabB[db][0][0])
assert np.isclose(tab[dc][1][0][0], tabA[da][0][0][0] * tabB[db][1][0])
assert np.isclose(tab[dc][2][0][0], tabA[da][1][0][0] * tabB[db][0][0])
assert np.isclose(tab[dc][3][0][0], tabA[da][1][0][0] * tabB[db][1][0])
assert np.isclose(tab[dc][4][0][0], tabA[da][2][0][0] * tabB[db][0][0])
assert np.isclose(tab[dc][5][0][0], tabA[da][2][0][0] * tabB[db][1][0])
assert np.isclose(tab[dc][0][1][0], tabA[da][0][1][0] * tabB[db][0][0])
assert np.isclose(tab[dc][1][1][0], tabA[da][0][1][0] * tabB[db][1][0])
assert np.isclose(tab[dc][2][1][0], tabA[da][1][1][0] * tabB[db][0][0])
assert np.isclose(tab[dc][3][1][0], tabA[da][1][1][0] * tabB[db][1][0])
assert np.isclose(tab[dc][4][1][0], tabA[da][2][1][0] * tabB[db][0][0])
assert np.isclose(tab[dc][5][1][0], tabA[da][2][1][0] * tabB[db][1][0])
assert tab[dc][0][2][0] == 0.0
assert tab[dc][1][2][0] == 0.0
assert tab[dc][2][2][0] == 0.0
assert tab[dc][3][2][0] == 0.0
assert tab[dc][4][2][0] == 0.0
assert tab[dc][5][2][0] == 0.0
def test_TFE_2Dx1D_scalar_quad():
T = UFCInterval()
P1 = Lagrange(T, 1)
P1_DG = DiscontinuousLagrange(T, 1)
elt = TensorProductElement(TensorProductElement(P1, P1_DG), P1)
assert elt.value_shape() == ()
tab = elt.tabulate(1, [(0.1, 0.2, 0.3)])
tA = P1.tabulate(1, [(0.1, )])
tB = P1_DG.tabulate(1, [(0.2, )])
tC = P1.tabulate(1, [(0.3, )])
for da, db, dc in [[(0, ), (0, ), (0, )], [(1, ), (0, ), (0, )],
[(0, ), (1, ), (0, )], [(0, ), (0, ), (1, )]]:
dd = da + db + dc
assert np.isclose(tab[dd][0][0],
tA[da][0][0] * tB[db][0][0] * tC[dc][0][0])
assert np.isclose(tab[dd][1][0],
tA[da][0][0] * tB[db][0][0] * tC[dc][1][0])
assert np.isclose(tab[dd][2][0],
tA[da][0][0] * tB[db][1][0] * tC[dc][0][0])
assert np.isclose(tab[dd][3][0],
tA[da][0][0] * tB[db][1][0] * tC[dc][1][0])
assert np.isclose(tab[dd][4][0],
tA[da][1][0] * tB[db][0][0] * tC[dc][0][0])
assert np.isclose(tab[dd][5][0],
tA[da][1][0] * tB[db][0][0] * tC[dc][1][0])
assert np.isclose(tab[dd][6][0],
tA[da][1][0] * tB[db][1][0] * tC[dc][0][0])
assert np.isclose(tab[dd][7][0],
tA[da][1][0] * tB[db][1][0] * tC[dc][1][0])
def test_TFE_1Dx1D_vector():
T = UFCInterval()
P1_DG = DiscontinuousLagrange(T, 1)
P2 = Lagrange(T, 2)
elt = TensorProductElement(P1_DG, P2)
hdiv_elt = Hdiv(elt)
hcurl_elt = Hcurl(elt)
assert hdiv_elt.value_shape() == (2, )
assert hcurl_elt.value_shape() == (2, )
tabA = P1_DG.tabulate(1, [(0.1, )])
tabB = P2.tabulate(1, [(0.2, )])
hdiv_tab = hdiv_elt.tabulate(1, [(0.1, 0.2)])
for da, db in [[(0, ), (0, )], [(1, ), (0, )], [(0, ), (1, )]]:
dc = da + db
assert hdiv_tab[dc][0][0][0] == 0.0
assert hdiv_tab[dc][1][0][0] == 0.0
assert hdiv_tab[dc][2][0][0] == 0.0
assert hdiv_tab[dc][3][0][0] == 0.0
assert hdiv_tab[dc][4][0][0] == 0.0
assert hdiv_tab[dc][5][0][0] == 0.0
assert np.isclose(hdiv_tab[dc][0][1][0],
tabA[da][0][0] * tabB[db][0][0])
assert np.isclose(hdiv_tab[dc][1][1][0],
tabA[da][0][0] * tabB[db][1][0])
assert np.isclose(hdiv_tab[dc][2][1][0],
tabA[da][0][0] * tabB[db][2][0])
assert np.isclose(hdiv_tab[dc][3][1][0],
tabA[da][1][0] * tabB[db][0][0])
assert np.isclose(hdiv_tab[dc][4][1][0],
tabA[da][1][0] * tabB[db][1][0])
assert np.isclose(hdiv_tab[dc][5][1][0],
tabA[da][1][0] * tabB[db][2][0])
hcurl_tab = hcurl_elt.tabulate(1, [(0.1, 0.2)])
for da, db in [[(0, ), (0, )], [(1, ), (0, )], [(0, ), (1, )]]:
dc = da + db
assert np.isclose(hcurl_tab[dc][0][0][0],
tabA[da][0][0] * tabB[db][0][0])
assert np.isclose(hcurl_tab[dc][1][0][0],
tabA[da][0][0] * tabB[db][1][0])
assert np.isclose(hcurl_tab[dc][2][0][0],
tabA[da][0][0] * tabB[db][2][0])
assert np.isclose(hcurl_tab[dc][3][0][0],
tabA[da][1][0] * tabB[db][0][0])
assert np.isclose(hcurl_tab[dc][4][0][0],
tabA[da][1][0] * tabB[db][1][0])
assert np.isclose(hcurl_tab[dc][5][0][0],
tabA[da][1][0] * tabB[db][2][0])
assert hcurl_tab[dc][0][1][0] == 0.0
assert hcurl_tab[dc][1][1][0] == 0.0
assert hcurl_tab[dc][2][1][0] == 0.0
assert hcurl_tab[dc][3][1][0] == 0.0
assert hcurl_tab[dc][4][1][0] == 0.0
assert hcurl_tab[dc][5][1][0] == 0.0
def test_mixed_is_not_nodal():
element = MixedElement([
EnrichedElement(
RaviartThomas(T, 1),
RestrictedElement(RaviartThomas(T, 2),
restriction_domain="interior")),
DiscontinuousLagrange(T, 1)
])
assert not element.is_nodal()
def test_TFE_1Dx1D_scalar():
T = UFCInterval()
P1_DG = DiscontinuousLagrange(T, 1)
P2 = Lagrange(T, 2)
elt = TensorProductElement(P1_DG, P2)
assert elt.value_shape() == ()
tab = elt.tabulate(1, [(0.1, 0.2)])
tabA = P1_DG.tabulate(1, [(0.1, )])
tabB = P2.tabulate(1, [(0.2, )])
for da, db in [[(0, ), (0, )], [(1, ), (0, )], [(0, ), (1, )]]:
dc = da + db
assert np.isclose(tab[dc][0][0], tabA[da][0][0] * tabB[db][0][0])
assert np.isclose(tab[dc][1][0], tabA[da][0][0] * tabB[db][1][0])
assert np.isclose(tab[dc][2][0], tabA[da][0][0] * tabB[db][2][0])
assert np.isclose(tab[dc][3][0], tabA[da][1][0] * tabB[db][0][0])
assert np.isclose(tab[dc][4][0], tabA[da][1][0] * tabB[db][1][0])
assert np.isclose(tab[dc][5][0], tabA[da][1][0] * tabB[db][2][0])
def __init__(self, ref_el, degree):
sd = ref_el.get_spatial_dimension()
if sd in (0, 1):
raise ValueError(
"Cannot use this trace class on a %d-dimensional cell." % sd)
# Constructing facet element as a discontinuous Lagrange element
dglagrange = DiscontinuousLagrange(ufc_simplex(sd - 1), degree)
# Construct entity ids (assigning top. dim. and initializing as empty)
entity_dofs = {}
# Looping over dictionary of cell topology to construct the empty
# dictionary for entity ids of the trace element
topology = ref_el.get_topology()
for top_dim, entities in topology.items():
entity_dofs[top_dim] = {}
for entity in entities:
entity_dofs[top_dim][entity] = []
# Filling in entity ids and generating points for dual basis
nf = dglagrange.space_dimension()
points = []
num_facets = sd + 1
for f in range(num_facets):
entity_dofs[sd - 1][f] = range(f * nf, (f + 1) * nf)
for dof in dglagrange.dual_basis():
facet_point = list(dof.get_point_dict().keys())[0]
transform = ref_el.get_entity_transform(sd - 1, f)
points.append(tuple(transform(facet_point)))
# Setting up dual basis - only point evaluations
nodes = [PointEvaluation(ref_el, pt) for pt in points]
dual = dual_set.DualSet(nodes, ref_el, entity_dofs)
super(HDivTrace, self).__init__(ref_el, dual, dglagrange.get_order(),
dglagrange.get_formdegree(),
dglagrange.mapping()[0])
# Set up facet element
self.facet_element = dglagrange
# degree for quadrature rule
self.polydegree = degree
def test_TFE_2Dx1D_scalar_triangle_hdiv():
S = UFCTriangle()
T = UFCInterval()
P1_DG = DiscontinuousLagrange(S, 1)
P2 = Lagrange(T, 2)
elt = Hdiv(TensorProductElement(P1_DG, P2))
assert elt.value_shape() == (3, )
tab = elt.tabulate(1, [(0.1, 0.2, 0.3)])
tabA = P1_DG.tabulate(1, [(0.1, 0.2)])
tabB = P2.tabulate(1, [(0.3, )])
for da, db in [[(0, 0), (0, )], [(1, 0), (0, )], [(0, 1), (0, )],
[(0, 0), (1, )]]:
dc = da + db
assert tab[dc][0][0][0] == 0.0
assert tab[dc][1][0][0] == 0.0
assert tab[dc][2][0][0] == 0.0
assert tab[dc][3][0][0] == 0.0
assert tab[dc][4][0][0] == 0.0
assert tab[dc][5][0][0] == 0.0
assert tab[dc][6][0][0] == 0.0
assert tab[dc][7][0][0] == 0.0
assert tab[dc][8][0][0] == 0.0
assert tab[dc][0][1][0] == 0.0
assert tab[dc][1][1][0] == 0.0
assert tab[dc][2][1][0] == 0.0
assert tab[dc][3][1][0] == 0.0
assert tab[dc][4][1][0] == 0.0
assert tab[dc][5][1][0] == 0.0
assert tab[dc][6][1][0] == 0.0
assert tab[dc][7][1][0] == 0.0
assert tab[dc][8][1][0] == 0.0
assert np.isclose(tab[dc][0][2][0], tabA[da][0][0] * tabB[db][0][0])
assert np.isclose(tab[dc][1][2][0], tabA[da][0][0] * tabB[db][1][0])
assert np.isclose(tab[dc][2][2][0], tabA[da][0][0] * tabB[db][2][0])
assert np.isclose(tab[dc][3][2][0], tabA[da][1][0] * tabB[db][0][0])
assert np.isclose(tab[dc][4][2][0], tabA[da][1][0] * tabB[db][1][0])
assert np.isclose(tab[dc][5][2][0], tabA[da][1][0] * tabB[db][2][0])
assert np.isclose(tab[dc][6][2][0], tabA[da][2][0] * tabB[db][0][0])
assert np.isclose(tab[dc][7][2][0], tabA[da][2][0] * tabB[db][1][0])
assert np.isclose(tab[dc][8][2][0], tabA[da][2][0] * tabB[db][2][0])
def test_mixed_is_nodal():
element = MixedElement([DiscontinuousLagrange(T, 1), RaviartThomas(T, 2)])
assert element.is_nodal()
sys.path.insert(0, bsDir)
sys.path.insert(0, configDir)
if os.path.isdir(os.path.join(fiatDir, 'FIAT')):
sys.path.insert(0, fiatDir)
import PETSc.FEM
from FIAT.reference_element import default_simplex
from FIAT.lagrange import Lagrange
from FIAT.discontinuous_lagrange import DiscontinuousLagrange
generator = PETSc.FEM.QuadratureGenerator()
generator.setup()
elements = []
if not (len(sys.argv) - 2) % 5 == 0:
sys.exit('Incomplete set of arguments')
for n in range((len(sys.argv) - 2) / 5):
dim = int(sys.argv[n * 5 + 1])
order = int(sys.argv[n * 5 + 2])
components = int(sys.argv[n * 5 + 3])
numBlocks = int(sys.argv[n * 5 + 4])
operator = sys.argv[n * 5 + 5]
if order == 0:
element = DiscontinuousLagrange(default_simplex(1), order)
else:
element = Lagrange(default_simplex(1), order)
element.numComponents = components
elements.append(element)
filename = sys.argv[-1]
generator.quadDegree = max([e.order + 1 for e in elements])
generator.runTensorProduct(dim, elements, numBlocks, operator, filename)