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()
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()))