def test_pickling(): # some simple checks for pickle mesh = MeshQuad() elem = ElementQuad1() mapping = MappingIsoparametric(mesh, elem) basis = CellBasis(mesh, elem, mapping) pickled_mesh = pickle.dumps(mesh) pickled_elem = pickle.dumps(elem) pickled_mapping = pickle.dumps(mapping) pickled_basis = pickle.dumps(basis) mesh1 = pickle.loads(pickled_mesh) elem1 = pickle.loads(pickled_elem) mapping1 = pickle.loads(pickled_mapping) basis1 = pickle.loads(pickled_basis) assert_almost_equal( laplace.assemble(basis).toarray(), laplace.assemble(basis1).toarray(), ) assert_almost_equal( mesh.doflocs, mesh1.doflocs, ) assert_almost_equal( mapping.J(0, 0, np.array([[.3], [.3]])), mapping1.J(0, 0, np.array([[.3], [.3]])), ) assert_almost_equal( elem.doflocs, elem1.doflocs, )
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 test_periodic_loading(m, mdgtype, e): def _sort(ix): # sort index arrays so that ix[0] matches return ix[np.argsort(np.sum(m.p, axis=0)[ix])] mp = mdgtype.periodic(m, _sort(m.nodes_satisfying(lambda x: x[0] == 0)), _sort(m.nodes_satisfying(lambda x: x[0] == 1))) basis = Basis(mp, e) A = laplace.assemble(basis) M = mass.assemble(basis) @LinearForm def linf(v, w): return np.sin(2. * np.pi * w.x[0]) * v f = linf.assemble(basis) x = solve(A + 1e-6 * M, f) def uexact(x): return (1. / (2. * np.pi)**2) * np.sin(2. * np.pi * x[0]) @Functional def func(w): uexact = (1. / (2. * np.pi)**2) * np.sin(2. * np.pi * w.x[0]) return (uexact - w['u'])**2 assert_almost_equal(func.assemble(basis, u=x), 0, decimal=5)
def test_solving_inhomogeneous_laplace(mesh_elem, impose): """Adapted from example 14.""" mesh, elem = mesh_elem m = mesh().refined(4) basis = Basis(m, elem) boundary_basis = FacetBasis(m, 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(*impose(A, x=u, D=boundary_dofs)) @Functional def gradu(w): gradu = w['sol'].grad return dot(gradu, gradu) np.testing.assert_almost_equal(gradu.assemble(basis, sol=basis.interpolate(u)), 8 / 3, decimal=9)
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): m = self.init_mesh() basis = InteriorBasis(m, self.element_type()) A = laplace.assemble(basis) b = unit_load.assemble(basis) x = solve(*condense(A, b, D=basis.get_dofs())) self.assertAlmostEqual(np.max(x), self.maxval, places=3)
def runTest(self): path = Path(__file__).parents[1] / 'docs' / 'examples' / 'meshes' m = self.mesh_type.load(path / self.filename) basis = InteriorBasis(m, self.element_type()) A = laplace.assemble(basis) b = unit_load.assemble(basis) x = solve(*condense(A, b, D=basis.get_dofs())) self.assertAlmostEqual(np.max(x), 0.06261690318912218, places=3)
def test_periodic_mesh_assembly(m, mdgtype, etype, check1, check2): def _sort(ix): # sort index arrays so that ix[0] matches return ix[np.argsort(np.sum(m.p, axis=0)[ix])] mp = mdgtype.periodic(m, _sort(m.nodes_satisfying(check1)), _sort(m.nodes_satisfying(check2))) basis = Basis(mp, etype()) A = laplace.assemble(basis) 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()
def laplace(m, **params): """Solve the Laplace equation using the FEM. Parameters ---------- m A Mesh object. """ e = ElementTriP1() basis = CellBasis(m, e) A = laplacian.assemble(basis) b = unit_load.assemble(basis) u = solve(*condense(A, b, I=m.interior_nodes())) # evaluate the error estimators fbasis = [InteriorFacetBasis(m, e, side=i) for i in [0, 1]] w = {"u" + str(i + 1): fbasis[i].interpolate(u) for i in [0, 1]} @Functional def interior_residual(w): h = w.h return h**2 eta_K = interior_residual.elemental(basis) @Functional def edge_jump(w): h = w.h n = w.n dw1 = grad(w["u1"]) dw2 = grad(w["u2"]) return h * ((dw1[0] - dw2[0]) * n[0] + (dw1[1] - dw2[1]) * n[1])**2 eta_E = edge_jump.elemental(fbasis[0], **w) tmp = np.zeros(m.facets.shape[1]) np.add.at(tmp, fbasis[0].find, eta_E) eta_E = np.sum(0.5 * tmp[m.t2f], axis=0) return eta_E + eta_K
def assembler(m): basis = Basis(m, ElementTetP1()) return ( laplace.assemble(basis), unit_load.assemble(basis), )