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)