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):
m = MeshTri()
M = MeshTri()
M.translate((1.0, 0.0))
mesh = m + M
self.assertTrue(mesh.p.shape[1] == 6)
self.assertTrue(mesh.t.shape[1] == 4)
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)
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):
mesh = MeshTri()
mesh.refine(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):
m = MeshTri()
prev_t_size = -1
for itr in range(5):
red_ix = prev_t_size - 1 if prev_t_size != -1\
else m.t.shape[1] - 1
prev_t_size = m.t.shape[1]
prev_p_size = m.p.shape[1]
m = m.refined([red_ix])
# check that new size is current size + 4
self.assertEqual(prev_t_size, m.t.shape[1] - 4)
self.assertEqual(prev_p_size, m.p.shape[1] - 3)
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
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()
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()
e = ElementTriArgyris()
basis = InteriorBasis(m, e)
all_dofs = basis.get_dofs()
self.assertEqual(len(all_dofs.keep('u').nodal), 1)
self.assertTrue('u' in all_dofs.keep('u').nodal)
self.assertEqual(len(all_dofs.keep('u_n').facet), 1)
self.assertEqual(len(all_dofs.drop('u').facet), 1)
all_dofs = basis.dofs.get_facet_dofs(m.facets_satisfying(lambda x: 1))
self.assertEqual(len(all_dofs.keep('u_n').facet), 1)
self.assertEqual(len(all_dofs.drop('u').facet), 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 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 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_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()
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.define_boundary('centreline',
lambda x: x[0] == .5,
boundaries_only=False)
m = m.refined(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 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):
m = MeshTri()
M = MeshTri()
M.translate((1.0, 0.0))
M.define_boundary('top', lambda x: x[1] == 1.0)
mesh = m + M
self.assertTrue(mesh.p.shape[1] == 6)
self.assertTrue(mesh.t.shape[1] == 4)
self.assertTrue(mesh.subdomains is None)
self.assertTrue('top' in mesh.boundaries)
def check_equivalence(self, ec, ev):
X = np.array([[0.125, 0.1111], [0.0555, 0.6]])
m = MeshTri.init_refdom()
mapping = MappingAffine(m)
for k in range(6):
for i in [0, 1]:
# accessing i'th component looks slightly different
assert_array_equal(
ev.gbasis(mapping, X, k)[0].f[i],
ec.gbasis(mapping, X, k)[i].f)
for j in [0, 1]:
assert_array_equal(
ev.gbasis(mapping, X, k)[0].df[i][j],
ec.gbasis(mapping, X, k)[i].df[j])
def runTest(self):
mesh = MeshTri().refined(5)
basis = CellBasis(mesh, ElementTriP1())
def fun(X):
x, y = X
return x**2 + y**2
x = 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):
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 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 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 runTest(self):
m = MeshTri()
e = ElementTriArgyris()
basis = InteriorBasis(m, e)
all_dofs = basis.get_dofs()
assert_allclose(
all_dofs.keep(['u', 'u_n']).keep('u'), all_dofs.keep('u'))
assert_allclose(
all_dofs.drop(['u_x', 'u_y', 'u_xx', 'u_xy', 'u_yy', 'u_n']),
all_dofs.keep('u'))
assert_allclose(all_dofs, all_dofs.drop('does_not_exist'))
assert_allclose(np.empty((0, ), dtype=np.int64),
all_dofs.keep('does_not_exist'))
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)
class TestEnforce(TestCase):
mesh = MeshTri()
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)
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):
# 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())
def runTest(self):
# Mesh.remove
m = MeshTri().refined()
M = m.remove_elements(np.array([0]))
self.assertEqual(M.t.shape[1], 7)
# boundaries
M = m.with_boundaries({
'foo': lambda x: x[0] == 0.,
})
self.assertEqual(M.boundaries['foo'].size, 2)
m = MeshHex().scaled(0.5).translated((0.5, 0.5, 0.5))
self.assertGreater(np.min(m.p), 0.4999)
# Mesh3D.facets_satisfying
self.assertEqual(len(m.facets_satisfying(lambda x: x[0] == 0.5)), 1)