def as_fiat_cell(cell):
"""Convert a ufl cell to a FIAT cell.
:arg cell: the :class:`ufl.Cell` to convert."""
if not isinstance(cell, ufl.AbstractCell):
raise ValueError("Expecting a UFL Cell")
return FIAT.ufc_cell(cell)
def as_fiat_cell(cell):
"""Convert a ufl cell to a FIAT cell.
:arg cell: the :class:`ufl.Cell` to convert."""
if not isinstance(cell, ufl.AbstractCell):
raise ValueError("Expecting a UFL Cell")
return FIAT.ufc_cell(cell)
def test_mesh_topology_against_fiat(mesh_factory, ghost_mode):
"""Test that mesh cells have topology matching to FIAT reference
cell they were created from.
"""
func, args = mesh_factory
xfail_ghosted_quads_hexes(func, ghost_mode)
mesh = func(*args)
# Create FIAT cell
cell_name = CellType.type2string(mesh.type().cell_type())
fiat_cell = FIAT.ufc_cell(cell_name)
# Initialize all mesh entities and connectivities
mesh.init()
for cell in Cells(mesh):
# Get mesh-global (MPI-local) indices of cell vertices
vertex_global_indices = cell.entities(0)
# Loop over all dimensions of reference cell topology
for d, d_topology in fiat_cell.get_topology().items():
# Get entities of dimension d on the cell
entities = cell.entities(d)
if len(entities) == 0: # Fixup for highest dimension
entities = (cell.index(), )
# Loop over all entities of fixed dimension d
for entity_index, entity_topology in d_topology.items():
# Check that entity vertices map to cell vertices in right order
entity = MeshEntity(mesh, d, entities[entity_index])
entity_vertices = entity.entities(0)
assert all(vertex_global_indices[numpy.array(entity_topology)]
== entity_vertices)
def reference_cell(cell):
# really want to be using cells only, but sometimes only cellname is passed
# in. FIAT handles the cases.
# I hope nothing is still passing in just dimension...
if isinstance(cell, int):
error("%s was passed into reference_cell(). Need cell or cellname." % str(cell))
return FIAT.ufc_cell(cell)
def _create_finiteelement(element: ufl.FiniteElement) -> FIAT.FiniteElement:
"""Create FIAT element for UFL base type ufl.FiniteElement."""
if element.family() == "Real":
e = create_element(ufl.FiniteElement("DG", element.cell(), 0))
e.__class__ = type('SpaceOfReals', (type(e), SpaceOfReals), {})
return e
if element.family() == "Quadrature":
assert element.degree() is not None
assert element.quadrature_scheme() is not None
# Create quadrature (only interested in points)
# TODO: KBO: What should we do about quadrature functions that live on ds, dS?
# Get cell and facet names.
points, weights = create_quadrature(element.cell().cellname(),
element.degree(),
element.quadrature_scheme())
return FIAT.QuadratureElement(FIAT.ufc_cell(element.cell().cellname()),
points)
# Handle tensor-product structured elements
if element.cell().cellname() == "quadrilateral":
e = _create_element(element.reconstruct(cell=_tpc_quadrilateral))
return FIAT.tensor_product.FlattenedDimensions(e)
elif element.cell().cellname() == "hexahedron":
e = _create_element(element.reconstruct(cell=_tpc_hexahedron))
return FIAT.tensor_product.FlattenedDimensions(e)
if element.family() not in FIAT.supported_elements:
raise ValueError(
"Finite element of type \"{}\" is not supported by FIAT.".format(
element.family()))
# Handle Lagrange variants
if element.family() == "Lagrange" and element.variant() == "spectral":
assert element.cell().cellname() == "interval"
element_class = FIAT.GaussLobattoLegendre
else:
element_class = FIAT.supported_elements[element.family()]
assert element.degree() is not None
return element_class(FIAT.ufc_cell(element.cell().cellname()),
element.degree())
def reference_cell(cell):
# really want to be using cells only, but sometimes only cellname is passed
# in. FIAT handles the cases.
# I hope nothing is still passing in just dimension...
if isinstance(cell, int):
error("%s was passed into reference_cell(). Need cell or cellname." %
str(cell))
return FIAT.ufc_cell(cell)
def test_kronecker(degree):
cell = FIAT.ufc_cell("quadrilateral")
element = finat.DirectSerendipity(cell, degree)
pts = finat.point_set.PointSet(get_pts(cell, degree))
vertices = np.asarray(((0.0, 0.0), (1.0, 0.0), (0.1, 1.1), (0.95, 1.01)))
mapping = MyMapping(cell, vertices)
z = tuple([0] * cell.get_spatial_dimension())
vals = element.basis_evaluation(0, pts, coordinate_mapping=mapping)[z]
numvals = gem.interpreter.evaluate([vals])[0].arr
assert np.allclose(numvals, np.eye(*numvals.shape))
def map_facet_points(points, facet, cellname):
"""Map points from a facet to a cell.
Map points from the (UFC) reference simplex of dimension d - 1 to a
given facet on the (UFC) reference simplex of dimension d. This may
be used to transform points tabulated for example on the 2D
reference triangle to points on a given facet of the reference
tetrahedron.
"""
# Extract the geometric dimension of the points we want to map
dim = len(points[0]) + 1
# Special case, don't need to map coordinates on vertices
if dim == 1:
return [[(0.0, ), (1.0, )][facet]]
# Get the FIAT reference cell
fiat_cell = FIAT.ufc_cell(cellname)
# Extract vertex coordinates from cell and map of facet index to
# indicent vertex indices
coordinate_dofs = fiat_cell.get_vertices()
facet_vertices = fiat_cell.get_topology()[dim - 1]
# coordinate_dofs = \
# {1: ((0.,), (1.,)),
# 2: ((0., 0.), (1., 0.), (0., 1.)),
# 3: ((0., 0., 0.), (1., 0., 0.),(0., 1., 0.), (0., 0., 1))}
# Facet vertices
# facet_vertices = \
# {2: ((1, 2), (0, 2), (0, 1)),
# 3: ((1, 2, 3), (0, 2, 3), (0, 1, 3), (0, 1, 2))}
# Compute coordinates and map the points
coordinates = [coordinate_dofs[v] for v in facet_vertices[facet]]
new_points = []
for point in points:
w = (1.0 - sum(point), ) + tuple(point)
x = tuple(
sum([w[i] * numpy.array(coordinates[i]) for i in range(len(w))]))
new_points += [x]
return new_points
def create_quadrature(shape, degree: int, scheme: str = "default"):
"""Generate quadrature rule.
Quadrature rule(points, weights) for given shape that will integrate
an polynomial of order 'degree' exactly.
"""
if isinstance(shape, int) and shape == 0:
return (numpy.zeros((1, 0)), numpy.ones((1, )))
if shape in ufl.cell.cellname2dim and ufl.cell.cellname2dim[shape] == 0:
return (numpy.zeros((1, 0)), numpy.ones((1, )))
quad_rule = FIAT.create_quadrature(FIAT.ufc_cell(shape), degree, scheme)
points = numpy.asarray(quad_rule.get_points())
weights = numpy.asarray(quad_rule.get_weights())
return points, weights
def test_mesh_topology_against_fiat(mesh_factory,
ghost_mode=cpp.mesh.GhostMode.none):
"""Test that mesh cells have topology matching to FIAT reference
cell they were created from.
"""
func, args = mesh_factory
xfail_ghosted_quads_hexes(func, ghost_mode)
mesh = func(*args)
if not is_simplex(mesh.topology.cell_type):
return
# Create FIAT cell
cell_name = cpp.mesh.to_string(mesh.topology.cell_type)
fiat_cell = FIAT.ufc_cell(cell_name)
# Initialize all mesh entities and connectivities
mesh.topology.create_connectivity_all()
map = mesh.topology.index_map(mesh.topology.dim)
num_cells = map.size_local + map.num_ghosts
for i in range(num_cells):
cell = MeshEntity(mesh, mesh.topology.dim, i)
# Get mesh-global (MPI-local) indices of cell vertices
vertex_global_indices = cell.entities(0)
# Loop over all dimensions of reference cell topology
for d, d_topology in fiat_cell.get_topology().items():
# Get entities of dimension d on the cell
entities = cell.entities(d)
if len(entities) == 0: # Fixup for highest dimension
entities = (i, )
# Loop over all entities of fixed dimension d
for entity_index, entity_topology in d_topology.items():
# Check that entity vertices map to cell vertices in correct order
entity = MeshEntity(mesh, d, entities[entity_index])
vertices_dolfin = np.sort(entity.entities(0))
vertices_fiat = np.sort(
vertex_global_indices[np.array(entity_topology)])
assert all(vertices_fiat == vertices_dolfin)
def test_mesh_topology_against_fiat(mesh_factory, ghost_mode):
"""Test that mesh cells have topology matching to FIAT reference
cell they were created from.
"""
func, args = mesh_factory
xfail_ghosted_quads_hexes(func, ghost_mode)
mesh = func(*args)
assert mesh.ordered()
tdim = mesh.topology().dim()
# Create FIAT cell
cell_name = CellType.type2string(mesh.type().cell_type())
fiat_cell = FIAT.ufc_cell(cell_name)
# Initialize all mesh entities and connectivities
mesh.init()
for cell in cells(mesh):
# Get mesh-global (MPI-local) indices of cell vertices
vertex_global_indices = cell.entities(0)
# Loop over all dimensions of reference cell topology
for d, d_topology in fiat_cell.get_topology().items():
# Get entities of dimension d on the cell
entities = cell.entities(d)
if len(entities) == 0: # Fixup for highest dimension
entities = (cell.index(),)
# Loop over all entities of fixed dimension d
for entity_index, entity_topology in d_topology.items():
# Check that entity vertices map to cell vertices in right order
entity = MeshEntity(mesh, d, entities[entity_index])
entity_vertices = entity.entities(0)
assert all(vertex_global_indices[numpy.array(entity_topology)]
== entity_vertices)
def reference_cell(cellname):
"""Return FIAT reference cell."""
return FIAT.ufc_cell(cellname)
def reference_cell_vertices(cellname):
"""Return dict of coordinates of reference cell vertices for this 'cellname'."""
return FIAT.ufc_cell(cellname).get_vertices()
def reference_cell(cellname):
"Return FIAT reference cell"
return FIAT.ufc_cell(cellname)
