class TestNodality(TestCase):
"""Test for Element.doflocs."""
elems = [
ElementLineP0(),
ElementLineP1(),
ElementLineP2(),
ElementLinePp(1),
ElementLinePp(3),
ElementLineMini(),
ElementTriP0(),
ElementTriP1(),
ElementTriP2(),
ElementTriP3(),
ElementTriP4(),
ElementTriMini(),
ElementQuad0(),
ElementQuad1(),
ElementQuad2(),
ElementQuadS2(),
ElementQuadP(1),
ElementQuadP(3),
ElementTetP0(),
ElementTetP1(),
ElementTetP2(),
ElementTetMini(),
ElementHex1(),
ElementHexS2(),
ElementHex2(),
ElementTetCR(),
ElementTetCCR(),
ElementTriCR(),
ElementTriCCR(),
ElementWedge1(),
]
def runTest(self):
for e in self.elems:
N = e.doflocs.shape[0]
Ih = np.zeros((N, N))
for itr in range(N):
Ih[itr] = e.lbasis(e.doflocs.T, itr)[0]
# Remove nan-rows: test nodality only on non-nan doflocs.
#
# Some elements, such as ElementTriMini might have a combination
# of nodal dofs and non-nodal dofs.
#
# Nodal dof is defined so that there exists a point where the
# corresponding basis function is one, and other basis functions
# are zero. Non-nodal dof does not satisfy this property.
ix = np.isnan(np.sum(Ih, axis=1))
Nnan = np.sum(ix)
ixs = np.nonzero(~ix)[0]
Ih = Ih[ixs].T[ixs].T
assert_allclose(Ih,
np.eye(N - Nnan),
atol=1e-13,
err_msg="{}".format(type(e)))
class SolveInhomogeneousLaplace(TestCase):
"""Adapted from example 14."""
mesh = MeshTri
elem = ElementTriP2()
def runTest(self):
m = self.mesh().refined(4)
basis = InteriorBasis(m, self.elem)
boundary_basis = FacetBasis(m, self.elem)
boundary_dofs = boundary_basis.get_dofs().flatten()
def dirichlet(x):
"""return a harmonic function"""
return ((x[0] + 1.j * x[1])**2).real
u = basis.zeros()
A = laplace.assemble(basis)
u[boundary_dofs] = projection(dirichlet,
boundary_basis,
I=boundary_dofs)
u = solve(*enforce(A, x=u, D=boundary_dofs))
@Functional
def gradu(w):
gradu = w['sol'].grad
return dot(gradu, gradu)
self.assertAlmostEqual(
gradu.assemble(basis, sol=basis.interpolate(u)),
8 / 3,
delta=1e-10,
)
class TestPartitionofUnity(TestCase):
"""Test that elements form a partition of unity."""
elems = [
ElementLineP1(),
ElementLineP2(),
ElementTriP1(),
ElementTriP2(),
ElementQuad1(),
ElementQuad2(),
ElementQuadS2(),
ElementTetP1(),
ElementTetP2(),
ElementHex1(),
ElementHexS2(),
ElementHex2(),
]
def runTest(self):
for elem in self.elems:
if elem.dim == 1:
y = np.array([[.15]])
elif elem.dim == 2:
y = np.array([[.15], [.15]])
elif elem.dim == 3:
y = np.array([[.15], [.15], [.15]])
out = 0.
for i in range(elem.doflocs.shape[0]):
out += elem.lbasis(y, i)[0][0]
self.assertAlmostEqual(out, 1, msg='failed for {}'.format(elem))
def __init__(self, doflocs, t, **kwargs):
warnings.warn("MeshTri2 is an experimental feature and "
"not governed by the semantic versioning. "
"Several features of MeshTri are still "
"missing.")
if t.shape[0] == 6:
dofs, ix = np.unique(t[:3], return_inverse=True)
super(MeshTri2, self).__init__(
doflocs[:, dofs],
np.arange(len(dofs), dtype=np.int)[ix].reshape(t[:3].shape),
sort_t=False,
**kwargs)
else:
# fallback for refinterp
super(MeshTri2, self).__init__(doflocs, t, **kwargs)
from skfem.element import ElementTriP2
from skfem.assembly import InteriorBasis
from skfem.mapping import MappingAffine
self._elem = ElementTriP2()
self._basis = InteriorBasis(self, self._elem, MappingAffine(self))
self._mesh = MeshTri.from_basis(self._basis)
if t.shape[0] == 6:
self._mesh.p = doflocs
self._mesh.t = t
def test_subdomain_facet_assembly():
def subdomain(x):
return np.logical_and(
np.logical_and(x[0] > .25, x[0] < .75),
np.logical_and(x[1] > .25, x[1] < .75),
)
m, e = MeshTri().refined(4), ElementTriP2()
cbasis = CellBasis(m, e)
cbasis_p0 = cbasis.with_element(ElementTriP0())
sfbasis = FacetBasis(m, e, facets=m.facets_around(subdomain, flip=True))
sfbasis_p0 = sfbasis.with_element(ElementTriP0())
sigma = cbasis_p0.zeros() + 1
@BilinearForm
def laplace(u, v, w):
return dot(w.sigma * grad(u), grad(v))
A = laplace.assemble(cbasis, sigma=cbasis_p0.interpolate(sigma))
u0 = cbasis.zeros()
u0[cbasis.get_dofs(elements=subdomain)] = 1
u0_dofs = cbasis.get_dofs() + cbasis.get_dofs(elements=subdomain)
A, b = enforce(A, D=u0_dofs, x=u0)
u = solve(A, b)
@Functional
def measure_current(w):
return dot(w.n, w.sigma * grad(w.u))
meas = measure_current.assemble(sfbasis,
sigma=sfbasis_p0.interpolate(sigma),
u=sfbasis.interpolate(u))
assert_almost_equal(meas, 9.751915526759191)
class TestDerivatives(TestCase):
"""Test values of derivatives."""
elems = [
ElementLineP1(),
ElementLineP2(),
ElementTriP1(),
ElementTriP2(),
ElementTriMini(),
ElementQuad1(),
ElementQuad2(),
ElementQuadS2(),
ElementTetP1(),
ElementTetP2(),
ElementTetMini(),
ElementHex1(),
ElementHexS2(),
]
def runTest(self):
for elem in self.elems:
eps = 1e-6
for base in [0., .3, .6, .9]:
if elem.dim == 1:
y = np.array([[base, base + eps]])
elif elem.dim == 2:
y = np.array([[base, base + eps, base, base],
[base, base, base, base + eps]])
elif elem.dim == 3:
y = np.array([[base, base + eps, base, base, base, base],
[base, base, base, base + eps, base, base],
[base, base, base, base, base, base + eps]])
i = 0
while True:
try:
out = elem.lbasis(y, i)
except ValueError:
break
diff = (out[0][1] - out[0][0]) / eps
errmsg = 'x-derivative for {}th bfun failed for {}'
self.assertAlmostEqual(diff,
out[1][0][0],
delta=1e-3,
msg=errmsg.format(i, elem))
if elem.dim > 1:
diff = (out[0][3] - out[0][2]) / eps
errmsg = 'y-derivative for {}th bfun failed for {}'
self.assertAlmostEqual(diff,
out[1][1][3],
delta=1e-3,
msg=errmsg.format(i, elem))
if elem.dim == 3:
diff = (out[0][5] - out[0][4]) / eps
errmsg = 'z-derivative for {}th bfun failed for {}'
self.assertAlmostEqual(diff,
out[1][2][4],
delta=1e-3,
msg=errmsg.format(i, elem))
i += 1
def runTest(self):
m = MeshTri()
basis = InteriorBasis(m, ElementTriP2())
dofs = basis.get_dofs()
self.assertEqual(len(dofs.nodal['u']), 4)
self.assertEqual(len(dofs.facet['u']), 4)
def runTest(self):
m = MeshTri()
basis = InteriorBasis(m, ElementTriP2())
D1 = basis.get_dofs(lambda x: x[0] == 0)
D2 = basis.get_dofs(lambda x: x[0] == 1)
D3 = basis.get_dofs(lambda x: x[1] == 1)
D4 = basis.get_dofs(lambda x: x[1] == 0)
assert_allclose(D1 | D2 | D3 | D4, basis.get_dofs())
assert_allclose(D1 + D2 + D3 + D4, basis.get_dofs())
def runTest(self):
"""Solve Stokes problem, try splitting and other small things."""
m = MeshTri().refined()
m = m.refined(3).with_boundaries({
'up': lambda x: x[1] == 1.,
'rest': lambda x: x[1] != 1.,
})
e = ElementVectorH1(ElementTriP2()) * ElementTriP1()
basis = CellBasis(m, e)
@BilinearForm
def bilinf(u, p, v, q, w):
from skfem.helpers import grad, ddot, div
return (ddot(grad(u), grad(v)) - div(u) * q - div(v) * p
- 1e-2 * p * q)
S = asm(bilinf, basis)
D = basis.find_dofs(skip=['u^2'])
x = basis.zeros()
x[D['up'].all('u^1^1')] = .1
x = solve(*condense(S, x=x, D=D))
(u, u_basis), (p, p_basis) = basis.split(x)
self.assertEqual(len(u), m.p.shape[1] * 2 + m.facets.shape[1] * 2)
self.assertEqual(len(p), m.p.shape[1])
self.assertTrue(np.sum(p - x[basis.nodal_dofs[2]]) < 1e-8)
U, P = basis.interpolate(x)
self.assertTrue(isinstance(U.value, np.ndarray))
self.assertTrue(isinstance(P.value, np.ndarray))
self.assertTrue(P.shape[0] == m.nelements)
self.assertTrue((basis.doflocs[:, D['up'].all()][1] == 1.).all())
# test blocks splitting of forms while at it
C1 = asm(bilinf.block(1, 1), CellBasis(m, ElementTriP1()))
C2 = S[basis.nodal_dofs[-1]].T[basis.nodal_dofs[-1]].T
self.assertTrue(abs((C1 - C2).min()) < 1e-10)
self.assertTrue(abs((C1 - C2).max()) < 1e-10)
# test splitting ElementVector
(ux, uxbasis), (uy, uybasis) = u_basis.split(u)
assert_allclose(ux[uxbasis.nodal_dofs[0]], u[u_basis.nodal_dofs[0]])
assert_allclose(ux[uxbasis.facet_dofs[0]], u[u_basis.facet_dofs[0]])
assert_allclose(uy[uybasis.nodal_dofs[0]], u[u_basis.nodal_dofs[1]])
assert_allclose(uy[uybasis.facet_dofs[0]], u[u_basis.facet_dofs[1]])
def runTest(self):
"""Solve Stokes problem, try splitting and other small things."""
m = MeshTri()
m.refine()
m.define_boundary('centreline',
lambda x: x[0] == .5,
boundaries_only=False)
m.refine(3)
e = ElementVectorH1(ElementTriP2()) * ElementTriP1()
m.define_boundary('up', lambda x: x[1] == 1.)
m.define_boundary('rest', lambda x: x[1] != 1.)
basis = InteriorBasis(m, e)
self.assertEqual(
basis.get_dofs(m.boundaries['centreline']).all().size,
(2 + 1) * (2**(1 + 3) + 1) + 2 * 2**(1 + 3))
self.assertEqual(basis.find_dofs()['centreline'].all().size,
(2 + 1) * (2**(1 + 3) + 1) + 2 * 2**(1 + 3))
@BilinearForm
def bilinf(u, p, v, q, w):
from skfem.helpers import grad, ddot, div
return (ddot(grad(u), grad(v)) - div(u) * q - div(v) * p -
1e-2 * p * q)
S = asm(bilinf, basis)
D = basis.find_dofs(skip=['u^2'])
x = basis.zeros()
x[D['up'].all('u^1^1')] = .1
x = solve(*condense(S, basis.zeros(), x=x, D=D))
(u, u_basis), (p, p_basis) = basis.split(x)
self.assertEqual(len(u), m.p.shape[1] * 2 + m.facets.shape[1] * 2)
self.assertEqual(len(p), m.p.shape[1])
self.assertTrue(np.sum(p - x[basis.nodal_dofs[2]]) < 1e-8)
U, P = basis.interpolate(x)
self.assertTrue(isinstance(U.value, np.ndarray))
self.assertTrue(isinstance(P.value, np.ndarray))
self.assertTrue((basis.doflocs[:, D['up'].all()][1] == 1.).all())
def runTest(self):
"""Solve Stokes problem, try splitting and other small things."""
m = MeshTri().refined()
m = m.refined(3).with_boundaries({
'up': lambda x: x[1] == 1.,
'rest': lambda x: x[1] != 1.,
})
e = ElementVectorH1(ElementTriP2()) * ElementTriP1()
basis = CellBasis(m, e)
@BilinearForm
def bilinf(u, p, v, q, w):
from skfem.helpers import grad, ddot, div
return (ddot(grad(u), grad(v)) - div(u) * q - div(v) * p
- 1e-2 * p * q)
S = asm(bilinf, basis)
D = basis.find_dofs(skip=['u^2'])
x = basis.zeros()
x[D['up'].all('u^1^1')] = .1
x = solve(*condense(S, x=x, D=D))
(u, u_basis), (p, p_basis) = basis.split(x)
self.assertEqual(len(u), m.p.shape[1] * 2 + m.facets.shape[1] * 2)
self.assertEqual(len(p), m.p.shape[1])
self.assertTrue(np.sum(p - x[basis.nodal_dofs[2]]) < 1e-8)
U, P = basis.interpolate(x)
self.assertTrue(isinstance(U.value, np.ndarray))
self.assertTrue(isinstance(P.value, np.ndarray))
self.assertTrue((basis.doflocs[:, D['up'].all()][1] == 1.).all())
def nonsym(u, v, w):
return u.grad[0] * v
@BilinearForm(nthreads=2)
def threaded_nonsym(u, v, w):
return u.grad[0] * v
assert_almost_equal(
nonsym.assemble(basis).toarray(),
threaded_nonsym.assemble(basis).toarray(),
)
@pytest.mark.parametrize("m,e,edg", [
(MeshTri().refined(), ElementTriP1(), ElementTriDG),
(MeshTri().refined(), ElementTriP2(), ElementTriDG),
(MeshTet().refined(), ElementTetP1(), ElementTetDG),
(MeshTet().refined(), ElementTetP2(), ElementTetDG),
(MeshTri().refined(), ElementTriMorley(), ElementTriDG),
(MeshTri().refined(), ElementTriHermite(), ElementTriDG),
(MeshQuad().refined(), ElementQuad1(), ElementQuadDG),
(MeshQuad().refined(), ElementQuad2(), ElementQuadDG),
(MeshQuad().refined(), ElementQuadP(4), ElementQuadDG),
(MeshHex().refined(), ElementHex2(), ElementHexDG),
])
def test_coodata_inverse(m, e, edg):
E = edg(e)
basis = Basis(m, E)
basisdg = Basis(m, E)
M1 = mass.assemble(basis)
element_type = ElementTetP1
maxval = 0.0405901240018571
def init_mesh(self):
return self.mesh_type.init_ball().scaled(0.5)
class SolveCirclePoissonTet2(SolveCirclePoisson):
mesh_type = MeshTet2
element_type = ElementTetP2
filename = "quadratic_sphere_tet.msh"
maxval = 0.0405901240018571
@pytest.mark.parametrize("mesh_elem", [(MeshTri, ElementTriP2()),
(MeshQuad, ElementQuad2())])
@pytest.mark.parametrize("impose", [enforce, penalize])
def test_solving_inhomogeneous_laplace(mesh_elem, impose):
"""Adapted from example 14."""
mesh, elem = mesh_elem
m = mesh().refined(4)
basis = Basis(m, elem)
boundary_basis = FacetBasis(m, elem)
boundary_dofs = boundary_basis.get_dofs().flatten()
def dirichlet(x):
"""return a harmonic function"""
return ((x[0] + 1.j * x[1])**2).real
def create_basis(self, m):
e = ElementTriP2()
return Basis(m, e)
class TestIncompatibleMeshElement(TestCase):
def runTest(self):
with self.assertRaises(ValueError):
m = MeshTri()
e = ElementTetP2()
basis = CellBasis(m, e)
@pytest.mark.parametrize(
"mtype,e,nrefs,npoints",
[
(MeshTri, ElementTriP1(), 0, 10),
(MeshTri, ElementTriP2(), 1, 10),
(MeshTri, ElementTriP1(), 5, 10),
(MeshTri, ElementTriP1(), 1, 3e5),
(MeshTet, ElementTetP2(), 1, 10),
(MeshTet, ElementTetP1(), 4, 10),
(MeshTet, ElementTetP1(), 1, 3e4),
(MeshQuad, ElementQuad1(), 1, 10),
(MeshQuad, ElementQuad1(), 1, 3e5),
(MeshHex, ElementHex1(), 1, 1e5),
(MeshWedge1, ElementWedge1(), 0, 10),
]
)
def test_interpolator_probes(mtype, e, nrefs, npoints):
m = mtype()
if nrefs > 0:
nrefs = 5
class TestIncompatibleMeshElement(TestCase):
def runTest(self):
with self.assertRaises(ValueError):
m = MeshTri()
e = ElementTetP2()
basis = InteriorBasis(m, e)
@pytest.mark.parametrize("mtype,e1,e2", [
(MeshTri, ElementTriP1(), ElementTriP0()),
(MeshTri, ElementTriP1(), ElementTriP1()),
(MeshTri, ElementTriP2(), ElementTriP1()),
(MeshTri, ElementTriP2(), ElementTriP2()),
(MeshTri, ElementTriP2(), None),
(MeshQuad, ElementQuad1(), ElementQuad0()),
(MeshQuad, ElementQuad1(), ElementQuad1()),
(MeshQuad, ElementQuad2(), ElementQuad2()),
(MeshTet, ElementTetP1(), ElementTetP0()),
(MeshTet, ElementTetP2(), ElementTetP2()),
(MeshHex, ElementHex1(), ElementHex0()),
(MeshHex, ElementHex1(), ElementHex1()),
(MeshHex, ElementHex2(), ElementHex2()),
])
def test_trace(mtype, e1, e2):
m = mtype().refined(3)
nrefs = 5
class TestIncompatibleMeshElement(TestCase):
def runTest(self):
with self.assertRaises(ValueError):
m = MeshTri()
e = ElementTetP2()
basis = InteriorBasis(m, e)
@pytest.mark.parametrize("mtype,e1,e2", [
(MeshTri, ElementTriP1(), ElementLineP0()),
(MeshTri, ElementTriP1(), ElementLineP1()),
(MeshTri, ElementTriP2(), ElementLineP1()),
(MeshTri, ElementTriP2(), ElementLineP2()),
(MeshTri, ElementTriP2(), None),
(MeshQuad, ElementQuad1(), ElementLineP0()),
(MeshQuad, ElementQuad1(), ElementLineP1()),
(MeshQuad, ElementQuad2(), ElementLineP2()),
(MeshTet, ElementTetP1(), ElementTriP0()),
(MeshTet, ElementTetP2(), ElementTriP2()),
(MeshHex, ElementHex1(), ElementQuad0()),
(MeshHex, ElementHex1(), ElementQuad1()),
(MeshHex, ElementHex2(), ElementQuad2()),
])
def test_trace(mtype, e1, e2):
m = mtype().refined(3)
