11642291501

Committed 02 Nov 2024 11:16AM UTC coverage: 81.168% (+0.5%) from 80.657%

Build # 11642291501

Build Type

push

github

Committed by

web-flow

Commit Message

Upload to coveralls and docs from CI job running against python 3.12 (#726)

Run Details

3474 of 4280 relevant lines covered (81.17%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

31.52

/ffcx/codegeneration/geometry.py

# Copyright (C) 2021 Matthew Scroggs
#
# This file is part of FFCx.(https://www.fenicsproject.org)
#
# SPDX-License-Identifier:    LGPL-3.0-or-later
"""Geometry."""

import basix
import numpy as np

import ffcx.codegeneration.lnodes as L


def write_table(tablename, cellname):
    """Write a table."""
    if tablename == "facet_edge_vertices":
        return facet_edge_vertices(tablename, cellname)
    if tablename == "reference_facet_jacobian":
        return reference_facet_jacobian(tablename, cellname)
    if tablename == "reference_cell_volume":
        return reference_cell_volume(tablename, cellname)
    if tablename == "reference_facet_volume":
        return reference_facet_volume(tablename, cellname)
    if tablename == "reference_edge_vectors":
        return reference_edge_vectors(tablename, cellname)
    if tablename == "facet_reference_edge_vectors":
        return facet_reference_edge_vectors(tablename, cellname)
    if tablename == "reference_facet_normals":
        return reference_facet_normals(tablename, cellname)
    if tablename == "facet_orientation":
        return facet_orientation(tablename, cellname)
    raise ValueError(f"Unknown geometry table name: {tablename}")


def facet_edge_vertices(tablename, cellname):
    """Write facet edge vertices."""
    celltype = getattr(basix.CellType, cellname)
    topology = basix.topology(celltype)
    triangle_edges = basix.topology(basix.CellType.triangle)[1]
    quadrilateral_edges = basix.topology(basix.CellType.quadrilateral)[1]

    if len(topology) != 4:
        raise ValueError("Can only get facet edges for 3D cells.")

    edge_vertices = []
    for facet in topology[-2]:
        if len(facet) == 3:
            edge_vertices += [[[facet[i] for i in edge] for edge in triangle_edges]]
        elif len(facet) == 4:
            edge_vertices += [[[facet[i] for i in edge] for edge in quadrilateral_edges]]
        else:
            raise ValueError("Only triangular and quadrilateral faces supported.")

    out = np.array(edge_vertices, dtype=int)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.INT)
    return L.ArrayDecl(symbol, values=out, const=True)


def reference_facet_jacobian(tablename, cellname):
    """Write a reference facet jacobian."""
    celltype = getattr(basix.CellType, cellname)
    out = basix.cell.facet_jacobians(celltype)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.ArrayDecl(symbol, values=out, const=True)


def reference_cell_volume(tablename, cellname):
    """Write a reference cell volume."""
    celltype = getattr(basix.CellType, cellname)
    out = basix.cell.volume(celltype)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.VariableDecl(symbol, out)


def reference_facet_volume(tablename, cellname):
    """Write a reference facet volume."""
    celltype = getattr(basix.CellType, cellname)
    volumes = basix.cell.facet_reference_volumes(celltype)
    for i in volumes[1:]:
        if not np.isclose(i, volumes[0]):
            raise ValueError("Reference facet volume not supported for this cell type.")
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.VariableDecl(symbol, volumes[0])


def reference_edge_vectors(tablename, cellname):
    """Write reference edge vectors."""
    celltype = getattr(basix.CellType, cellname)
    topology = basix.topology(celltype)
    geometry = basix.geometry(celltype)
    edge_vectors = [geometry[j] - geometry[i] for i, j in topology[1]]
    out = np.array(edge_vectors)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.ArrayDecl(symbol, values=out, const=True)


def facet_reference_edge_vectors(tablename, cellname):
    """Write facet reference edge vectors."""
    celltype = getattr(basix.CellType, cellname)
    topology = basix.topology(celltype)
    geometry = basix.geometry(celltype)
    triangle_edges = basix.topology(basix.CellType.triangle)[1]
    quadrilateral_edges = basix.topology(basix.CellType.quadrilateral)[1]

    if len(topology) != 4:
        raise ValueError("Can only get facet edges for 3D cells.")

    edge_vectors = []
    for facet in topology[-2]:
        if len(facet) == 3:
            edge_vectors += [geometry[facet[j]] - geometry[facet[i]] for i, j in triangle_edges]
        elif len(facet) == 4:
            edge_vectors += [
                geometry[facet[j]] - geometry[facet[i]] for i, j in quadrilateral_edges
            ]
        else:
            raise ValueError("Only triangular and quadrilateral faces supported.")

    out = np.array(edge_vectors)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.ArrayDecl(symbol, values=out, const=True)


def reference_facet_normals(tablename, cellname):
    """Write reference facet normals."""
    celltype = getattr(basix.CellType, cellname)
    out = basix.cell.facet_outward_normals(celltype)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.ArrayDecl(symbol, values=out, const=True)


def facet_orientation(tablename, cellname):
    """Write facet orientations."""
    celltype = getattr(basix.CellType, cellname)
    out = basix.cell.facet_orientations(celltype)
    symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)
    return L.ArrayDecl(symbol, values=out, const=True)

1	# Copyright (C) 2021 Matthew Scroggs
2	#
3	# This file is part of FFCx.(https://www.fenicsproject.org)
4	#
5	# SPDX-License-Identifier: LGPL-3.0-or-later
6	"""Geometry."""
7
8	import basix	1✔
9	import numpy as np	1✔
10
11	import ffcx.codegeneration.lnodes as L	1✔
12
13
14	def write_table(tablename, cellname):	1✔
15	"""Write a table."""
16	if tablename == "facet_edge_vertices":	1✔
17	return facet_edge_vertices(tablename, cellname)	×
18	if tablename == "reference_facet_jacobian":	1✔
19	return reference_facet_jacobian(tablename, cellname)	1✔
20	if tablename == "reference_cell_volume":	1✔
21	return reference_cell_volume(tablename, cellname)	×
22	if tablename == "reference_facet_volume":	1✔
23	return reference_facet_volume(tablename, cellname)	×
24	if tablename == "reference_edge_vectors":	1✔
25	return reference_edge_vectors(tablename, cellname)	×
26	if tablename == "facet_reference_edge_vectors":	1✔
27	return facet_reference_edge_vectors(tablename, cellname)	×
28	if tablename == "reference_facet_normals":	1✔
29	return reference_facet_normals(tablename, cellname)	1✔
30	if tablename == "facet_orientation":	×
31	return facet_orientation(tablename, cellname)	×
32	raise ValueError(f"Unknown geometry table name: {tablename}")	×
33
34
35	def facet_edge_vertices(tablename, cellname):	1✔
36	"""Write facet edge vertices."""
37	celltype = getattr(basix.CellType, cellname)	×
38	topology = basix.topology(celltype)	×
39	triangle_edges = basix.topology(basix.CellType.triangle)[1]	×
40	quadrilateral_edges = basix.topology(basix.CellType.quadrilateral)[1]	×
41
42	if len(topology) != 4:	×
43	raise ValueError("Can only get facet edges for 3D cells.")	×
44
45	edge_vertices = []	×
46	for facet in topology[-2]:	×
47	if len(facet) == 3:	×
48	edge_vertices += [[[facet[i] for i in edge] for edge in triangle_edges]]	×
49	elif len(facet) == 4:	×
50	edge_vertices += [[[facet[i] for i in edge] for edge in quadrilateral_edges]]	×
51	else:
52	raise ValueError("Only triangular and quadrilateral faces supported.")	×
53
54	out = np.array(edge_vertices, dtype=int)	×
55	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.INT)	×
56	return L.ArrayDecl(symbol, values=out, const=True)	×
57
58
59	def reference_facet_jacobian(tablename, cellname):	1✔
60	"""Write a reference facet jacobian."""
61	celltype = getattr(basix.CellType, cellname)	1✔
62	out = basix.cell.facet_jacobians(celltype)	1✔
63	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	1✔
64	return L.ArrayDecl(symbol, values=out, const=True)	1✔
65
66
67	def reference_cell_volume(tablename, cellname):	1✔
68	"""Write a reference cell volume."""
69	celltype = getattr(basix.CellType, cellname)	×
70	out = basix.cell.volume(celltype)	×
71	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	×
72	return L.VariableDecl(symbol, out)	×
73
74
75	def reference_facet_volume(tablename, cellname):	1✔
76	"""Write a reference facet volume."""
77	celltype = getattr(basix.CellType, cellname)	×
78	volumes = basix.cell.facet_reference_volumes(celltype)	×
79	for i in volumes[1:]:	×
80	if not np.isclose(i, volumes[0]):	×
81	raise ValueError("Reference facet volume not supported for this cell type.")	×
82	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	×
83	return L.VariableDecl(symbol, volumes[0])	×
84
85
86	def reference_edge_vectors(tablename, cellname):	1✔
87	"""Write reference edge vectors."""
88	celltype = getattr(basix.CellType, cellname)	×
89	topology = basix.topology(celltype)	×
90	geometry = basix.geometry(celltype)	×
91	edge_vectors = [geometry[j] - geometry[i] for i, j in topology[1]]	×
92	out = np.array(edge_vectors)	×
93	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	×
94	return L.ArrayDecl(symbol, values=out, const=True)	×
95
96
97	def facet_reference_edge_vectors(tablename, cellname):	1✔
98	"""Write facet reference edge vectors."""
99	celltype = getattr(basix.CellType, cellname)	×
100	topology = basix.topology(celltype)	×
101	geometry = basix.geometry(celltype)	×
102	triangle_edges = basix.topology(basix.CellType.triangle)[1]	×
103	quadrilateral_edges = basix.topology(basix.CellType.quadrilateral)[1]	×
104
105	if len(topology) != 4:	×
106	raise ValueError("Can only get facet edges for 3D cells.")	×
107
108	edge_vectors = []	×
109	for facet in topology[-2]:	×
110	if len(facet) == 3:	×
111	edge_vectors += [geometry[facet[j]] - geometry[facet[i]] for i, j in triangle_edges]	×
112	elif len(facet) == 4:	×
113	edge_vectors += [	×
114	geometry[facet[j]] - geometry[facet[i]] for i, j in quadrilateral_edges
115	]
116	else:
117	raise ValueError("Only triangular and quadrilateral faces supported.")	×
118
119	out = np.array(edge_vectors)	×
120	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	×
121	return L.ArrayDecl(symbol, values=out, const=True)	×
122
123
124	def reference_facet_normals(tablename, cellname):	1✔
125	"""Write reference facet normals."""
126	celltype = getattr(basix.CellType, cellname)	1✔
127	out = basix.cell.facet_outward_normals(celltype)	1✔
128	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	1✔
129	return L.ArrayDecl(symbol, values=out, const=True)	1✔
130
131
132	def facet_orientation(tablename, cellname):	1✔
133	"""Write facet orientations."""
134	celltype = getattr(basix.CellType, cellname)	×
135	out = basix.cell.facet_orientations(celltype)	×
136	symbol = L.Symbol(f"{cellname}_{tablename}", dtype=L.DataType.REAL)	×
137	return L.ArrayDecl(symbol, values=out, const=True)	×

FEniCS / ffcx / 11642291501

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous