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)