def runTest(self):
m = MeshTet()
# default mesh has all edges on the boundary
self.assertEqual(len(m.boundary_edges()), m.edges.shape[1])
# check that there is a correct amount of boundary edges:
# 12 (cube edges) * 2 (per cube edge)
# + 6 (cube faces) * 8 (per cube face)
# = 72 edges
self.assertTrue(len(m.refined().boundary_edges()) == 72)
def runTest(self):
m1 = MeshTet()
m2 = m1.mirrored((1, 0, 0))
m3 = m1.mirrored((0, 1, 0))
m4 = m1.mirrored((0, 0, 1))
m = m1 + m2 + m3 + m4
self.assertEqual(m.nvertices, 20)
self.assertEqual(m.nelements, 20)
def test_adaptive_splitting_3d_5():
# random refine
m = MeshTet()
np.random.seed(1337)
for itr in range(10):
m = m.refined(
np.unique(
np.random.randint(0,
m.t.shape[1],
size=int(0.3 * m.t.shape[1]))))
assert m.is_valid()
class ConvergenceTetP2(ConvergenceTetP1):
rateL2 = 3.23
rateH1 = 1.94
eps = 0.01
def create_basis(self, m):
e = ElementTetP2()
return InteriorBasis(m, e)
def setUp(self):
self.mesh = MeshTet()
self.mesh.refine(1)
class ConvergenceTetP1(ConvergenceQ1):
rateL2 = 2.0
rateH1 = 1.0
eps = 0.13
def create_basis(self, m):
e = ElementTetP1()
return InteriorBasis(m, e)
def setUp(self):
self.mesh = MeshTet()
self.mesh.refine(2)
class ConvergenceRaviartThomas3D(ConvergenceRaviartThomas):
rateL2 = .5
rateHdiv = 1.0
eps = 0.1
Hdivbound = 0.3
L2bound = 0.05
def create_basis(self, m):
e = ElementTetRT0()
e0 = ElementTetP0()
return (InteriorBasis(m, e,
intorder=2), InteriorBasis(m, e0, intorder=2))
def setUp(self):
self.mesh = MeshTet()
self.mesh.refine(1)
def test_adaptive_splitting_3d_3():
# adaptively refine one face of a cube, check that the mesh parameter h
# is approximately linear w.r.t to distance from the face
m = MeshTet.init_tensor(np.linspace(0, 1, 3), np.linspace(0, 1, 3),
np.linspace(0, 1, 3))
for itr in range(15):
m = m.refined(m.f2t[0, m.facets_satisfying(lambda x: x[0] == 0)])
@LinearForm
def hproj(v, w):
return w.h * v
basis = Basis(m, ElementTetP1())
h = projection(hproj, basis)
funh = basis.interpolator(h)
xs = np.vstack((
np.linspace(0, .5, 20),
np.zeros(20) + .5,
np.zeros(20) + .5,
))
hs = funh(xs)
assert np.max(np.abs(hs - xs[0])) < 0.063
def runTest(self):
m1 = MeshTet()
m2 = m1.mirrored((1, 0, 0))
m3 = m1.mirrored((0, 1, 0))
m4 = m1.mirrored((0, 0, 1))
m = m1 + m2 + m3 + m4
self.assertEqual(m.nvertices, 20)
self.assertEqual(m.nelements, 20)
m = MeshTri.init_tensor(
np.linspace(1, 2, 2),
np.linspace(1, 2, 2),
)
m = m + m.mirrored((0, 1), (2, 1))
self.assertEqual(len(m.boundary_facets()), 6)
self.assertEqual(m.nvertices, 6)
def runTest(self):
with self.assertRaises(Exception):
# point belonging to no element
MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T,
np.array([[0, 1, 2]]).T)
with self.assertRaises(Exception):
# wrong size inputs (t not matching to Mesh type)
MeshTet(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T,
np.array([[0, 1, 2]]).T)
with self.assertRaises(Exception):
# inputting trasposes
MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]),
np.array([[0, 1, 2], [1, 2, 3]]))
with self.assertRaises(Exception):
# floats in element connectivity
MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T,
np.array([[0.0, 1.0, 2.0], [1.0, 2.0, 3.0]]).T)
def runTest(self):
# submeshes
examples = Path(__file__).parents[1] / 'docs' / 'examples'
m = MeshTet.load(str(examples / 'box.msh'))
self.assertTrue((m.boundaries['top']
== m.facets_satisfying(lambda x: x[1] == 1)).all())
self.assertTrue((m.boundaries['back']
== m.facets_satisfying(lambda x: x[2] == 0)).all())
self.assertTrue((m.boundaries['front']
== m.facets_satisfying(lambda x: x[2] == 1)).all())
m = MeshTri.load(str(examples / 'square.msh'))
self.assertTrue((m.boundaries['top']
== m.facets_satisfying(lambda x: x[1] == 1)).all())
self.assertTrue((m.boundaries['left']
== m.facets_satisfying(lambda x: x[0] == 0)).all())
self.assertTrue((m.boundaries['right']
== m.facets_satisfying(lambda x: x[0] == 1)).all())
def test_adaptive_splitting_3d_4():
# check that the same mesh is reproduced by any future versions
m = MeshTet.init_tensor(np.linspace(0, 1, 2), np.linspace(0, 1, 2),
np.linspace(0, 1, 2))
m = m.refined(m.f2t[0, m.facets_satisfying(lambda x: x[0] == 0)])
assert_array_equal(
m.p,
np.array([[0., 0., 1., 1., 0., 0., 1., 1., 0.5],
[0., 1., 0., 1., 0., 1., 0., 1., 0.5],
[0., 0., 0., 0., 1., 1., 1., 1., 0.5]]))
assert_array_equal(
m.t,
np.array([[5, 3, 3, 5, 6, 6, 1, 4, 1, 2, 2, 4],
[0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7],
[1, 1, 2, 4, 2, 4, 5, 5, 3, 3, 6, 6],
[8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]]))
def runTest(self):
# submeshes
m = MeshTet.load(MESH_PATH / 'box.msh')
self.assertTrue(
(m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1)
).all())
self.assertTrue(
(m.boundaries['back'] == m.facets_satisfying(lambda x: x[2] == 0)
).all())
self.assertTrue(
(m.boundaries['front'] == m.facets_satisfying(lambda x: x[2] == 1)
).all())
m = MeshTri.load(MESH_PATH / 'square.msh')
self.assertTrue(
(m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1)
).all())
self.assertTrue(
(m.boundaries['left'] == m.facets_satisfying(lambda x: x[0] == 0)
).all())
self.assertTrue(
(m.boundaries['right'] == m.facets_satisfying(lambda x: x[0] == 1)
).all())
if self.test_integrate_volume:
# by Gauss theorem this integrates to one
for itr in range(m.p.shape[0]):
@LinearForm
def linf(v, w):
return w.n[itr] * v
b = asm(linf, basis)
self.assertAlmostEqual(b @ m.p[itr, :], 1.0, places=5)
class NormalVectorTestTet(NormalVectorTestTri):
case = (MeshTet(), ElementTetP1())
class NormalVectorTestTetP2(NormalVectorTestTri):
case = (MeshTet(), ElementTetP2())
test_integrate_volume = False
class NormalVectorTestQuad(NormalVectorTestTri):
case = (MeshQuad(), ElementQuad1())
class NormalVectorTestQuadP(NormalVectorTestTri):
def setUp(self):
self.mesh = MeshTet()
self.mesh.refine(1)
m = MeshTet()
np.random.seed(1337)
for itr in range(10):
m = m.refined(
np.unique(
np.random.randint(0,
m.t.shape[1],
size=int(0.3 * m.t.shape[1]))))
assert m.is_valid()
@pytest.mark.parametrize(
"m,seed",
[
(MeshTet(), 0),
(MeshTet(), 1), # problems
(MeshTet(), 2),
(MeshTet(), 3),
(MeshTet().refined(), 10),
])
def test_adaptive_random_splitting(m, seed):
np.random.seed(seed)
points = np.hstack((m.p, np.random.rand(m.p.shape[0], 100)))
tri = Delaunay(points.T)
m = type(m)(points, tri.simplices.T)
assert m.is_valid()
for itr in range(3):
M = m.refined(
def setUp(self):
self.mesh = MeshTet().refined(1)
boundary_integral.assemble(sfbasis, u=m.p[0] * m.p[1]),
boundary_integral.assemble(fbasis, u=m.p[0] * m.p[1]),
)
@pytest.mark.parametrize(
"m, e, facets, fun",
[
(
MeshTri.load(MESH_PATH / 'interface.msh'),
ElementTriP1(),
'interfacee',
lambda m: m.p[1],
),
(
MeshTet.load(MESH_PATH / 'cuubat.msh'),
ElementTetP1(),
'interface',
lambda m: m.p[0],
)
]
)
def test_oriented_interface_integral(m, e, facets, fun):
fb = FacetBasis(m, e, facets=facets)
assert_almost_equal(
Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=fun(m)),
1.0,
)
if self.test_integrate_volume:
# by Gauss theorem this integrates to one
for itr in range(m.p.shape[0]):
@LinearForm
def linf(v, w):
return w.n[itr] * v
b = asm(linf, basis)
self.assertAlmostEqual(b @ m.p[itr, :], 1.0, places=5)
class NormalVectorTestTet(NormalVectorTestTri):
case = (MeshTet(), ElementTetP1())
class NormalVectorTestTetP2(NormalVectorTestTri):
case = (MeshTet(), ElementTetP2())
test_integrate_volume = False
class NormalVectorTestQuad(NormalVectorTestTri):
case = (MeshQuad(), ElementQuad1())
class NormalVectorTestQuadP(NormalVectorTestTri):
class TestElementQuadBFS(TestCase):
def test_throw_index_error(self):
"""Tests that exception is thrown when i % 4 not in (0, 1, 2, 3)."""
element = ElementQuadBFS()
with self.assertRaises(ValueError):
element.gdof(0, 0, -1)
with self.assertRaises(ValueError):
element.gdof(0, 0, 16)
@pytest.mark.parametrize("m,e,edg", [
(MeshTri().refined(), ElementTriP1(), ElementTriDG),
(MeshTri().refined(), ElementTriP2(), ElementTriDG),
(MeshTet().refined(), ElementTetP1(), ElementTetDG),
(MeshTet().refined(), ElementTetP2(), ElementTetDG),
(MeshTri().refined(), ElementTriArgyris(), ElementTriDG),
(MeshTri().refined(), ElementTriMorley(), ElementTriDG),
(MeshTri().refined(), ElementTriHermite(), ElementTriDG),
(MeshHex().refined(), ElementHex1(), ElementHexDG),
(MeshQuad().refined(), ElementQuad1(), ElementQuadDG),
])
def test_dg_element(m, e, edg):
edg = edg(e)
@Functional
def square(w):
return w['random']**2
def test_adaptive_splitting_3d():
m = MeshTet()
for itr in range(10):
M = m.refined([itr, itr + 1, itr + 2])
assert M.is_valid()
m = M
def test_adaptive_splitting_3d_1():
m = MeshTet()
for itr in range(50):
m = m.refined([itr])
assert m.is_valid()
def test_adaptive_splitting_3d_2():
m = MeshTet()
for itr in range(5):
m = m.refined(np.arange(m.nelements, dtype=np.int64))
assert m.is_valid()
