bempp 0.2.0

Boundary element method library.
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

import pytest
from bempp.function_space import function_space
from ndgrid.shapes import regular_sphere
from ndelement.ciarlet import create_family, Family, Continuity
from ndelement.reference_cell import ReferenceCellType


@pytest.mark.parametrize("level", range(4))
def test_create_space_dp0(level):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, 0, Continuity.Discontinuous)

    space = function_space(grid, element)

    assert space.local_size == grid.entity_count(ReferenceCellType.Triangle)
    assert space.local_size == space.global_size
    assert space.is_serial


@pytest.mark.parametrize("level", range(4))
def test_create_space_p1(level):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, 1)
    space = function_space(grid, element)

    assert space.local_size == grid.entity_count(ReferenceCellType.Point)
    assert space.local_size == space.global_size
    assert space.is_serial


@pytest.mark.parametrize("level", range(4))
def test_create_space_p2(level):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, 2)
    space = function_space(grid, element)

    assert space.local_size == grid.entity_count(ReferenceCellType.Point) + grid.entity_count(
        ReferenceCellType.Interval
    )
    assert space.local_size == space.global_size
    assert space.is_serial


@pytest.mark.parametrize("level", range(4))
def test_grid(level):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, 1)
    space = function_space(grid, element)

    assert space.grid.topology_dim == 2
    assert space.grid.geometry_dim == 3
    for e in [
        ReferenceCellType.Point,
        ReferenceCellType.Interval,
        ReferenceCellType.Triangle,
        ReferenceCellType.Quadrilateral,
    ]:
        assert space.grid.entity_count(e) == grid.entity_count(e)


@pytest.mark.parametrize("level", range(4))
def test_element(level):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, 1)
    space = function_space(grid, element)

    e = ReferenceCellType.Triangle
    assert space.element(e).dim == element.element(e).dim
    assert space.element(e).entity_dofs(0, 0) == element.element(e).entity_dofs(0, 0)


@pytest.mark.parametrize("level", range(4))
@pytest.mark.parametrize("degree", range(1, 5))
def test_get_local_dof_numbers(level, degree):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, degree)
    space = function_space(grid, element)

    for i in range(grid.entity_count(ReferenceCellType.Point)):
        assert len(space.get_local_dof_numbers(0, i)) == 1
    for i in range(grid.entity_count(ReferenceCellType.Interval)):
        assert len(space.get_local_dof_numbers(1, i)) == degree - 1
    for i in range(grid.entity_count(ReferenceCellType.Triangle)):
        assert len(space.get_local_dof_numbers(2, i)) == (degree - 1) * (degree - 2) // 2


@pytest.mark.parametrize("level", range(4))
@pytest.mark.parametrize("degree", range(1, 5))
def test_cell_dofs(level, degree):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, degree)
    space = function_space(grid, element)

    for i in range(grid.entity_count(ReferenceCellType.Triangle)):
        assert len(space.cell_dofs(i)) == (degree + 1) * (degree + 2) // 2


@pytest.mark.parametrize("level", range(4))
@pytest.mark.parametrize("degree", range(1, 5))
def test_global_dofs(level, degree):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, degree)
    space = function_space(grid, element)

    assert space.local_size == space.global_size
    for i in range(space.local_size):
        assert space.global_dof_index(i) == i


@pytest.mark.parametrize("level", range(4))
@pytest.mark.parametrize("degree", range(1, 5))
def test_ownership(level, degree):
    grid = regular_sphere(level)
    element = create_family(Family.Lagrange, degree)
    space = function_space(grid, element)

    assert space.local_size == space.global_size
    for i in range(space.local_size):
        assert space.ownership(i).is_owned