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))
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)))
def __init__(self, doflocs, t, **kwargs):
warnings.warn("MeshQuad2 is an experimental feature and "
"not governed by the semantic versioning. "
"Several features of MeshQuad are still "
"missing.")
if t.shape[0] == 9:
dofs, ix = np.unique(t[:4], return_inverse=True)
super(MeshQuad2, self).__init__(
doflocs[:, dofs],
np.arange(len(dofs), dtype=np.int)[ix].reshape(t[:4].shape),
**kwargs)
else:
# fallback for refinterp
super(MeshQuad2, self).__init__(doflocs, t, **kwargs)
from skfem.element import ElementQuad1, ElementQuad2
from skfem.assembly import InteriorBasis
from skfem.mapping import MappingIsoparametric
self._elem = ElementQuad2()
self._basis = InteriorBasis(self, self._elem,
MappingIsoparametric(self, ElementQuad1()))
self._mesh = MeshQuad.from_basis(self._basis)
if t.shape[0] == 9:
self._mesh.p = doflocs
self._mesh.t = t
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
class SolveInhomogeneousLaplaceQuad(SolveInhomogeneousLaplace):
mesh = MeshQuad
elem = ElementQuad2()
test_integrate_volume = False
class NormalVectorTestHex2(NormalVectorTestTri):
case = (MeshHex(), ElementHex2())
intorder = 3
test_integrate_volume = False
@pytest.mark.parametrize("mtype,e,mtype2", [
(MeshTri, ElementTriP1(), None),
(MeshTri, ElementTriArgyris(), None),
(MeshHex, ElementHex1(), None),
(MeshQuad, ElementQuad1(), None),
(MeshQuad, ElementQuad2(), None),
(MeshQuad, ElementQuad2(), MeshQuad2),
(MeshTri, ElementTriP1(), MeshTri2),
(MeshTet, ElementTetP1(), MeshTet2),
(MeshHex, ElementHex1(), MeshHex2),
])
def test_evaluate_functional(mtype, e, mtype2):
m = mtype().refined(3)
if mtype2 is not None:
m = mtype2.from_mesh(m)
basis = Basis(m, e)
@Functional
def x_squared(w):
return w.x[0]**2
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 = ElementQuad2()
return Basis(m, e)
@pytest.mark.parametrize(
"mtype,e1,e2,flat",
[
(MeshTri, ElementTriP1(), ElementTriP0(), False),
(MeshTri, ElementTriP1(), ElementTriP1(), False),
(MeshTri, ElementTriP2(), ElementTriP1(), False),
(MeshTri, ElementTriP2(), ElementTriP2(), False),
(MeshTri, ElementTriP1(), ElementTriP0(), True),
(MeshTri, ElementTriP1(), ElementTriP1(), True),
(MeshTri, ElementTriP2(), ElementTriP1(), True),
(MeshTri, ElementTriP2(), ElementTriP2(), True),
(MeshTri, ElementTriP2(), None, False),
(MeshTri, ElementTriP2(), None, True),
(MeshQuad, ElementQuad1(), ElementQuad0(), False),
(MeshQuad, ElementQuad1(), ElementQuad1(), False),
(MeshQuad, ElementQuad2(), ElementQuad2(), False),
(MeshQuad, ElementQuad1(), ElementQuad0(), True),
(MeshQuad, ElementQuad1(), ElementQuad1(), True),
(MeshQuad, ElementQuad2(), ElementQuad2(), True),
(MeshTet, ElementTetP1(), ElementTetP0(), False),
(MeshTet, ElementTetP2(), ElementTetP2(), False),
(MeshHex, ElementHex1(), ElementHex0(), False),
(MeshHex, ElementHex1(), ElementHex1(), False),
(MeshHex, ElementHex2(), ElementHex2(), False),
],
)
def test_trace(mtype, e1, e2, flat):
m = mtype().refined(3)
# use the boundary where last coordinate is zero
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)
# use the boundary where last coordinate is zero
basis = FacetBasis(
m, e1, facets=m.facets_satisfying(lambda x: x[x.shape[0] - 1] == 0.0))
xfun = projection(lambda x: x[0], InteriorBasis(m, e1))
nbasis, y = basis.trace(xfun,
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)
# use the boundary where last coordinate is zero
basis = FacetBasis(
m, e1, facets=m.facets_satisfying(lambda x: x[x.shape[0] - 1] == 0.0))
xfun = project(lambda x: x[0], basis_to=InteriorBasis(m, e1))
nbasis, y = basis.trace(xfun,
class NormalVectorTestHex2(NormalVectorTestTri):
case = (MeshHex(), ElementHex2())
intorder = 3
test_integrate_volume = False
@pytest.mark.parametrize(
"mtype,e,mtype2",
[
(MeshTri, ElementTriP1(), None),
(MeshTri, ElementTriArgyris(), None),
(MeshHex, ElementHex1(), None),
(MeshQuad, ElementQuad1(), None),
(MeshQuad, ElementQuad2(), None),
(MeshQuad, ElementQuad2(), MeshQuad2),
(MeshTri, ElementTriP1(), MeshTri2),
(MeshTet, ElementTetP1(), MeshTet2),
(MeshHex, ElementHex1(), MeshHex2),
]
)
def test_evaluate_functional(mtype, e, mtype2):
m = mtype().refined(3)
if mtype2 is not None:
m = mtype2.from_mesh(m)
basis = InteriorBasis(m, e)
@Functional
def x_squared(w):
return w.x[0] ** 2