def runTest(self):
m = MeshTri()
fbasis1 = FacetBasis(m, ElementTriP1() * ElementTriP1(),
facets=m.facets_satisfying(lambda x: x[0] == 0))
fbasis2 = FacetBasis(m, ElementTriP1(),
facets=lambda x: x[0] == 0)
fbasis3 = FacetBasis(m, ElementTriP1(), facets='left')
@BilinearForm
def uv1(u, p, v, q, w):
return u * v + p * q
@BilinearForm
def uv2(u, v, w):
return u * v
A = asm(uv1, fbasis1)
B = asm(uv2, fbasis2)
C = asm(uv2, fbasis2)
assert_allclose(A[0].todense()[0, ::2],
B[0].todense()[0])
assert_allclose(A[0].todense()[0, ::2],
C[0].todense()[0])
def runTest(self):
from skfem.element.element_composite import ElementComposite
self.check_equivalence(
ElementComposite(ElementTriP1(),
ElementTriP1()),
ElementVectorH1(ElementTriP1())
)
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 test_multimesh():
m1 = MeshTri().refined()
m2 = MeshQuad().refined().translated((1., 0.))
m3 = MeshTri().refined().translated((2., 0.))
M = m1 @ m2 @ m3
assert len(M) == 3
E = [ElementTriP1(), ElementQuad1(), ElementTriP1()]
basis = list(map(Basis, M, E))
Mm = asm(mass, basis)
assert Mm.shape[0] == 3 * 7
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)))
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):
@Functional
def hydrostatic_pressure(w):
return w.n * w.x[1]
np.testing.assert_allclose(
hydrostatic_pressure.assemble(FacetBasis(MeshTri(),
ElementTriP1())), [0, 1])
def test_multimesh_2():
m = MeshTri()
m1 = MeshTri.init_refdom()
m2 = MeshTri.init_refdom().scaled((-1., -1.)).translated((
1.,
1.,
))
M = m1 @ m2
E = [ElementTriP1(), ElementTriP1()]
basis1 = list(map(Basis, M, E))
basis2 = Basis(m, ElementTriP1())
M1 = asm(mass, basis1)
M2 = asm(mass, basis2)
assert_array_almost_equal(M1.toarray(), M2.toarray())
def test_basis_project_grad():
m, e = (MeshTri(), ElementTriP1())
basis = CellBasis(m, e)
Y = basis.interpolate(m.p[0])
y = basis.project(Y.grad[0])
@Functional
def int_y(w):
return w.y ** 2
assert_almost_equal(int_y.assemble(basis, y=y), 1.)
def runTest(self):
mesh = MeshTri().refined(5)
basis = InteriorBasis(mesh, ElementTriP1())
def fun(x, y):
return x**2 + y**2
x = L2_projection(fun, basis)
y = fun(*mesh.p)
normest = np.linalg.norm(x - y)
self.assertTrue(normest < 0.011, msg="|x-y| = {}".format(normest))
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):
m = self.mesh
e = ElementTriP1()
basis = InteriorBasis(m, e)
A = laplace.assemble(basis)
M = mass.assemble(basis)
D = m.boundary_nodes()
assert_almost_equal(enforce(A, D=D).toarray(), np.eye(A.shape[0]))
assert_almost_equal(enforce(M, D=D, diag=0.).toarray(),
np.zeros(M.shape))
enforce(A, D=D, overwrite=True)
assert_almost_equal(A.toarray(), np.eye(A.shape[0]))
def runTest(self):
m = MeshTri()
e = ElementTriP1()
basis = Basis(m, e)
@Functional
def feqx(w):
from skfem.helpers import grad
f = w['func'] # f(x) = x
return grad(f)[0] # f'(x) = 1
func = basis.interpolate(m.p[0])
# integrate f'(x) = 1 over [0, 1]^2
self.assertAlmostEqual(feqx.assemble(basis, func=func), 1.)
def test_subdomain_facet_assembly_2():
m = MeshTri().refined(4).with_subdomains({'all': lambda x: x[0] * 0 + 1})
e = ElementTriP1()
@Functional
def boundary_integral(w):
return dot(w.n, grad(w.u))
sfbasis = FacetBasis(m, e, facets=m.facets_around('all'))
fbasis = FacetBasis(m, e)
assert_almost_equal(
boundary_integral.assemble(sfbasis, u=m.p[0] * m.p[1]),
boundary_integral.assemble(fbasis, u=m.p[0] * m.p[1]),
)
def runTest(self):
m = MeshTri()
e = ElementTriP1()
basis = Basis(m, e)
@Functional
def feqx(w):
from skfem.helpers import grad
f = w['func'] # f(x, y) = x
g = w['gunc'] # g(x, y) = y
return grad(f)[0] + grad(g)[1]
func = basis.interpolate(m.p[0])
gunc = basis.interpolate(m.p[1])
self.assertAlmostEqual(feqx.assemble(basis, func=func, gunc=gunc), 2.)
def runTest(self):
m = MeshTri().refined()
e = ElementTriP1()
basis = Basis(m, e)
@BilinearForm
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(),
)
def test_mortar_basis(m1, m2, lenright):
# some sanity checks for MortarBasis
e = ElementTriP1()
mort = MappingMortar.init_2D(m1,
m2,
m1.boundaries['right'],
m2.boundaries['left'],
[0., 1.])
mb = [
MortarFacetBasis(m1, e, mapping=mort, intorder=4, side=0),
MortarFacetBasis(m2, e, mapping=mort, intorder=4, side=1),
]
@Functional
def unity(w):
return 1.
@LinearForm
def load(v, w):
return 1. * v
@BilinearForm
def mass(u, v, w):
return u * v
assert_almost_equal(unity.assemble(mb[0]), lenright)
assert_almost_equal(unity.assemble(mb[1]), lenright)
assert_almost_equal(load.assemble(mb[0]).dot(m1.p[1]), .5 * lenright)
assert_almost_equal(load.assemble(mb[1]).dot(m2.p[1]), .5 * lenright)
# integral is over the domain of the first argument
assert_almost_equal((mass.assemble(mb[0], mb[1])
.dot(m1.p[0] * 0. + 1.)
.dot(m2.p[0] * 0. + 1.)), lenright)
assert_almost_equal((mass.assemble(mb[1], mb[0])
.dot(m2.p[0] * 0. + 1.)
.dot(m1.p[0] * 0. + 1.)), lenright)
assert_allclose(mass.assemble(mb[0], mb[1]).toarray(),
mass.assemble(mb[1], mb[0]).T.toarray())
def test_simple_cg_solver():
m = MeshTri().refined(3)
basis = CellBasis(m, ElementTriP1())
A0 = laplace.coo_data(basis)
A1 = laplace.assemble(basis)
f = unit_load.assemble(basis)
D = m.boundary_nodes()
x1 = solve(*condense(A1, f, D=D))
f[D] = 0
x0 = A0.solve(f, D=D)
assert_almost_equal(x0, x1)
def runTest(self):
m = MeshTri()
e = ElementTriP1()
basis = Basis(m, e)
self.interior_area = 1
@BilinearForm(dtype=np.complex64)
def complexmass(u, v, w):
return 1j * u * v
@LinearForm(dtype=np.complex64)
def complexfun(v, w):
return 1j * v
M = asm(complexmass, basis)
f = asm(complexfun, basis)
ones = np.ones(M.shape[1])
self.assertAlmostEqual(np.dot(ones, M @ ones), 1j * self.interior_area)
self.assertAlmostEqual(np.dot(ones, f), 1j * self.interior_area)
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())
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()
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()
def mass(u, v, w):
return u * v
@LinearForm
def ones(v, w):
return 1. * v
M = asm(mass, basis)
f = asm(ones, basis)
return solve(M, f)
class NormalVectorTestTri(unittest.TestCase):
case = (MeshTri(), ElementTriP1())
test_integrate_volume = True
intorder = None
def runTest(self):
m = self.case[0].refined()
if self.intorder is not None:
basis = FacetBasis(m, self.case[1], intorder=self.intorder)
else:
basis = FacetBasis(m, self.case[1])
@LinearForm
def linf(v, w):
return np.sum(w.n**2, axis=0) * v
def mass(u, v, w):
return u * v
@LinearForm
def ones(v, w):
return 1. * v
M = asm(mass, basis)
f = asm(ones, basis)
return solve(M, f)
class NormalVectorTestTri(TestCase):
case = (MeshTri(), ElementTriP1())
test_integrate_volume = True
intorder = None
def runTest(self):
m = self.case[0].refined()
if self.intorder is not None:
basis = FacetBasis(m, self.case[1], intorder=self.intorder)
else:
basis = FacetBasis(m, self.case[1])
@LinearForm
def linf(v, w):
return np.sum(w.n**2, axis=0) * v
f = unit_load.assemble(basis)
D = basis.get_dofs()
x = solve(*condense(A, f, D=D))
if m.dim() == 2:
assert_almost_equal(x.max(), 0.125)
else:
assert_almost_equal(x.max(), 0.07389930610869411, decimal=3)
assert not np.isnan(x).any()
@pytest.mark.parametrize("m,mdgtype,e", [
(
MeshTri.init_tensor(np.linspace(0, 1, 7), np.linspace(0, 1, 7)),
MeshTri1DG,
ElementTriP1(),
),
(
MeshTri.init_tensor(np.linspace(0, 1, 5), np.linspace(0, 1, 5)),
MeshTri1DG,
ElementTriP1(),
),
(
MeshTri().refined(2),
MeshTri1DG,
ElementTriP1(),
),
(
MeshTri().refined(3),
MeshTri1DG,
ElementTriP1(),
def create_basis(self, m):
e = ElementTriP1()
return Basis(m, e)
with self.assertRaises(ValueError):
ElementLinePp(0)
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):
"""
from packaging import version
from pathlib import Path
from skfem.mesh import MeshTri
from skfem.assembly import InteriorBasis, FacetBasis
from skfem.utils import solve, asm, condense, projection
from skfem.element import ElementTriP1
from skfem.models.poisson import laplace, unit_load, mass
from skfem.io.json import from_file
import numpy as np
mesh = from_file(Path(__file__).parent / 'meshes' / 'ex35.json')
element = ElementTriP1()
# permeability of vacuum
mu0 = 1.25663706212e-6
# permittivity of vacuum
eps0 = 8.8541878128e-12
# relative permittivity of polytetrafluoroethylene
eps_ptfe = 2.1
# relative permittivity of fluorinated ethylene propylene
eps_fep = 2.1
global_basis = InteriorBasis(mesh, element)
inner_conductor_basis = InteriorBasis(
mesh, element, elements=mesh.subdomains['inner_conductor'])
outer_conductor_basis = InteriorBasis(
def runTest(self):
self.check_equivalence(ElementTriP1() * ElementTriP1(),
ElementVectorH1(ElementTriP1()))
