def test_dg_element(m, e, edg): edg = edg(e) @Functional def square(w): return w['random']**2 basis = InteriorBasis(m, e) basisdg = InteriorBasis(m, edg) assert_allclose( square.assemble(basis, random=basis.interpolate(basis.zeros() + 1)), square.assemble(basisdg, random=basisdg.interpolate(basisdg.zeros() + 1)), )
def runTest(self): m = self.mesh().refined(4) basis = InteriorBasis(m, self.elem) boundary_basis = FacetBasis(m, self.elem) boundary_dofs = boundary_basis.get_dofs().flatten() def dirichlet(x): """return a harmonic function""" return ((x[0] + 1.j * x[1])**2).real u = basis.zeros() A = laplace.assemble(basis) u[boundary_dofs] = projection(dirichlet, boundary_basis, I=boundary_dofs) u = solve(*enforce(A, x=u, D=boundary_dofs)) @Functional def gradu(w): gradu = w['sol'].grad return dot(gradu, gradu) self.assertAlmostEqual( gradu.assemble(basis, sol=basis.interpolate(u)), 8 / 3, delta=1e-10, )
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 = MeshTri() e = ElementTriP1() basis = InteriorBasis(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): m = MeshTri() e = ElementTriP1() basis = InteriorBasis(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 = self.case[0]() m.refine(self.prerefs) hs = [] L2s = [] for itr in range(3): e = self.case[1]() ib = InteriorBasis(m, e) @BilinearForm def bilinf(u, v, w): return ddot(dd(u), dd(v)) @LinearForm def linf(v, w): return 1. * v K = asm(bilinf, ib) f = asm(linf, ib) x = solve(*condense(K, f, D=ib.get_dofs().all())) X = ib.interpolate(x) def exact(x): return (x ** 2 - 2. * x ** 3 + x ** 4) / 24. @Functional def error(w): return (w.w - exact(w.x)) ** 2 L2 = np.sqrt(error.assemble(ib, w=X)) L2s.append(L2) hs.append(m.param()) m.refine() hs = np.array(hs) L2s = np.array(L2s) pfit = np.polyfit(np.log10(hs), np.log10(L2s), 1) self.assertGreater(pfit[0], self.limits[0]) self.assertLess(pfit[0], self.limits[1]) self.assertLess(L2s[-1], self.abs_limit)
def runTest(self): m = self.case[0]().refined(self.prerefs) hs = [] L2s = [] for itr in range(3): e = self.case[1]() ib = InteriorBasis(m, e) t = 1. E = 1. nu = 0.3 D = E * t ** 3 / (12. * (1. - nu ** 2)) @BilinearForm def bilinf(u, v, w): def C(T): trT = T[0, 0] + T[1, 1] return E / (1. + nu) * \ np.array([[T[0, 0] + nu / (1. - nu) * trT, T[0, 1]], [T[1, 0], T[1, 1] + nu / (1. - nu) * trT]]) return t ** 3 / 12.0 * ddot(C(dd(u)), dd(v)) def load(x): return np.sin(np.pi * x[0]) * np.sin(np.pi * x[1]) @LinearForm def linf(v, w): return load(w.x) * v K = asm(bilinf, ib) f = asm(linf, ib) # TODO fix boundary conditions # u_x should be zero on top/bottom # u_y should be zero on left/right x = solve(*condense(K, f, D=ib.get_dofs().all('u'))) X = ib.interpolate(x) def exact(x): return 1. / (4. * D * np.pi ** 4) * load(x) @Functional def error(w): return (w.w - exact(w.x)) ** 2 L2 = np.sqrt(error.assemble(ib, w=X)) L2s.append(L2) hs.append(m.param()) m = m.refined() hs = np.array(hs) L2s = np.array(L2s) pfit = np.polyfit(np.log10(hs), np.log10(L2s), 1) self.assertGreater(pfit[0], self.limits[0]) self.assertLess(pfit[0], self.limits[1]) self.assertLess(L2s[-1], self.abs_limit)