basix/test/utils.py at main · FEniCS/basix · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
# Copyright (c) 2020 Matthew Scroggs
# FEniCS Project
# SPDX-License-Identifier: MIT
"""Test utilities."""

import pytest

from basix import CellType, DPCVariant, ElementFamily, LagrangeVariant


def parametrize_over_elements(degree, reference=None, discontinuous=False):
    """Parametrize a test over a wide range of elements."""
    elementlist = []

    for k in range(1, degree + 1):
        # Elements on all cells
        for c in [
            CellType.interval,
            CellType.triangle,
            CellType.tetrahedron,
            CellType.quadrilateral,
            CellType.hexahedron,
            CellType.prism,
            CellType.pyramid,
        ]:
            if k < 4:
                elementlist.append((c, ElementFamily.P, k, [LagrangeVariant.equispaced]))

        # Elements on all cells except pyramid
        for c in [
            CellType.interval,
            CellType.triangle,
            CellType.tetrahedron,
            CellType.quadrilateral,
            CellType.hexahedron,
            CellType.prism,
        ]:
            elementlist.append((c, ElementFamily.P, k, [LagrangeVariant.gll_isaac]))
            elementlist.append((c, ElementFamily.P, k, [LagrangeVariant.gll_warped]))

        # Elements on all cells except prism and pyramid
        for c in [
            CellType.interval,
            CellType.triangle,
            CellType.tetrahedron,
            CellType.quadrilateral,
            CellType.hexahedron,
        ]:
            if discontinuous:
                elementlist.append((c, ElementFamily.P, k, [LagrangeVariant.legendre]))

            if (k <= 2 or c != CellType.triangle) and (k <= 1 or c != CellType.tetrahedron):
                if k < 4:
                    elementlist.append((c, ElementFamily.iso, k, [LagrangeVariant.equispaced]))
                elementlist.append((c, ElementFamily.iso, k, [LagrangeVariant.gll_warped]))
                elementlist.append((c, ElementFamily.iso, k, [LagrangeVariant.gll_isaac]))

        # Elements on all cells except prism, pyramid and interval
        for c in [
            CellType.triangle,
            CellType.tetrahedron,
            CellType.quadrilateral,
            CellType.hexahedron,
        ]:
            elementlist.append((c, ElementFamily.N1E, k, [LagrangeVariant.legendre]))
            elementlist.append(
                (c, ElementFamily.N2E, k, [LagrangeVariant.legendre, DPCVariant.legendre])
            )
            elementlist.append((c, ElementFamily.RT, k, [LagrangeVariant.legendre]))
            elementlist.append(
                (c, ElementFamily.BDM, k, [LagrangeVariant.legendre, DPCVariant.legendre])
            )
            if k == 1:
                elementlist.append((c, ElementFamily.CR, k, []))

        # Elements on simplex cells
        for c in [CellType.triangle, CellType.tetrahedron]:
            if k == 1:
                elementlist.append((c, ElementFamily.CR, k, []))
            elementlist.append((c, ElementFamily.Regge, k, []))
            if k == 3:
                elementlist.append((c, ElementFamily.Hermite, k, []))
            elementlist.append((c, ElementFamily.HHJ, k, []))

        # Elements on tensor product cells
        for c in [CellType.interval, CellType.quadrilateral, CellType.hexahedron]:
            for lv in [LagrangeVariant.equispaced, LagrangeVariant.gll_warped]:
                for dv in [DPCVariant.simplex_equispaced, DPCVariant.diagonal_gll]:
                    elementlist.append((c, ElementFamily.serendipity, k, [lv, dv]))

        # Elements on quads and hexes
        for c in [CellType.quadrilateral, CellType.hexahedron]:
            if discontinuous:
                for v in [
                    DPCVariant.simplex_equispaced,
                    DPCVariant.simplex_gll,
                    DPCVariant.horizontal_equispaced,
                    DPCVariant.horizontal_gll,
                    DPCVariant.diagonal_equispaced,
                    DPCVariant.diagonal_gll,
                ]:
                    elementlist.append((c, ElementFamily.DPC, k, [v]))

        # Bubble elements
        if k >= 2:
            elementlist.append((CellType.interval, ElementFamily.bubble, k, []))
            elementlist.append((CellType.quadrilateral, ElementFamily.bubble, k, []))
            elementlist.append((CellType.hexahedron, ElementFamily.bubble, k, []))
        if k >= 3:
            elementlist.append((CellType.triangle, ElementFamily.bubble, k, []))
        if k >= 4:
            elementlist.append((CellType.tetrahedron, ElementFamily.bubble, k, []))

    if reference is None:
        if len(elementlist) == 0:
            raise ValueError(f"No elements will be tested with reference: {reference}")
        return pytest.mark.parametrize("cell_type, element_type, degree, element_args", elementlist)
    else:
        elementlist = [(b, c, d) for a, b, c, d in elementlist if a == reference]
        if len(elementlist) == 0:
            raise ValueError(f"No elements will be tested with reference: {reference}")
        return pytest.mark.parametrize("element_type, degree, element_args", elementlist)