def __init__(self, doflocs, t, **kwargs): warnings.warn("MeshQuad2 is an experimental feature and " "not governed by the semantic versioning. " "Several features of MeshQuad are still " "missing.") if t.shape[0] == 9: dofs, ix = np.unique(t[:4], return_inverse=True) super(MeshQuad2, self).__init__( doflocs[:, dofs], np.arange(len(dofs), dtype=np.int)[ix].reshape(t[:4].shape), **kwargs) else: # fallback for refinterp super(MeshQuad2, self).__init__(doflocs, t, **kwargs) from skfem.element import ElementQuad1, ElementQuad2 from skfem.assembly import InteriorBasis from skfem.mapping import MappingIsoparametric self._elem = ElementQuad2() self._basis = InteriorBasis(self, self._elem, MappingIsoparametric(self, ElementQuad1())) self._mesh = MeshQuad.from_basis(self._basis) if t.shape[0] == 9: self._mesh.p = doflocs self._mesh.t = t
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)))
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, )
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 IntegrateOneOverBoundaryQ1(unittest.TestCase): elem = ElementQuad1() def createBasis(self): m = MeshQuad().refined(6) self.fbasis = FacetBasis(m, self.elem) self.boundary_area = 4.0000 def runTest(self): self.createBasis() @BilinearForm def uv(u, v, w): return u * v B = asm(uv, self.fbasis) @LinearForm def gv(v, w): return 1.0 * v g = asm(gv, self.fbasis) ones = np.ones(g.shape) self.assertAlmostEqual(ones @ g, self.boundary_area, places=4) self.assertAlmostEqual(ones @ (B @ ones), self.boundary_area, places=4)
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): m = MeshQuad().refined(2) e = ElementQuad1() basis = Basis(m, e) M, X = basis.refinterp(m.p[0], 3) self.assertEqual(M.p.shape[1], len(X))
def runTest(self): m = MeshQuad().refined(3) e = ElementQuad1() basis = InteriorBasis(m, e) @Functional def x_squared(w): return w.x[0]**2 y = asm(x_squared, basis) self.assertAlmostEqual(y, 1. / 3.) self.assertEqual(len(x_squared.elemental(basis)), m.t.shape[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 IntegrateOneOverBoundaryQ1(TestCase): elem = ElementQuad1() def createBasis(self): m = MeshQuad().refined(6) self.fbasis = FacetBasis(m, self.elem) self.boundary_area = 4.0000 def runTest(self): self.createBasis() @BilinearForm def uv(u, v, w): return u * v B = asm(uv, self.fbasis) # assemble the same matrix using multiple threads @BilinearForm(nthreads=2) def uvt(u, v, w): return u * v Bt = asm(uvt, self.fbasis) @LinearForm def gv(v, w): return 1.0 * v g = asm(gv, self.fbasis) ones = np.ones(g.shape) self.assertAlmostEqual(ones @ g, self.boundary_area, places=4) self.assertAlmostEqual(ones @ (B @ ones), self.boundary_area, places=4) self.assertAlmostEqual(ones @ (Bt @ ones), self.boundary_area, places=4)
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() if nrefs > 0: m = m.refined(nrefs) np.random.seed(0) X = np.random.rand(m.p.shape[0], int(npoints)) basis = CellBasis(m, e)
class NormalVectorTestTet(NormalVectorTestTri): case = (MeshTet(), ElementTetP1()) class NormalVectorTestTetP2(NormalVectorTestTri): case = (MeshTet(), ElementTetP2()) test_integrate_volume = False class NormalVectorTestQuad(NormalVectorTestTri): case = (MeshQuad(), ElementQuad1()) class NormalVectorTestQuadP(NormalVectorTestTri): case = (MeshQuad(), ElementQuadP(3)) test_integrate_volume = False class NormalVectorTestHex(NormalVectorTestTri): case = (MeshHex(), ElementHex1()) intorder = 3 class NormalVectorTestHexS2(NormalVectorTestTri):
ElementTriP1(), ), ( MeshTri().refined(2), MeshTri1DG, ElementTriP1(), ), ( MeshTri().refined(3), MeshTri1DG, ElementTriP1(), ), ( MeshQuad().refined(2), MeshQuad1DG, ElementQuad1(), ), ( MeshQuad().refined(2), MeshQuad1DG, ElementQuad2(), ), ( MeshTri().refined(2), MeshTri1DG, ElementTriP2(), ), ( MeshLine().refined(5), MeshLine1DG, ElementLineP1(),
def create_basis(self, m): e = ElementQuad1() return Basis(m, e)
def _mapping(self): from skfem.mapping import MappingIsoparametric from skfem.element import ElementQuad1, ElementLineP1 return MappingIsoparametric(self, ElementQuad1(), ElementLineP1())
class TestIncompatibleMeshElement(TestCase): def runTest(self): with self.assertRaises(ValueError): m = MeshTri() e = ElementTetP2() basis = InteriorBasis(m, e) @pytest.mark.parametrize("mtype,e1,e2", [ (MeshTri, ElementTriP1(), ElementLineP0()), (MeshTri, ElementTriP1(), ElementLineP1()), (MeshTri, ElementTriP2(), ElementLineP1()), (MeshTri, ElementTriP2(), ElementLineP2()), (MeshTri, ElementTriP2(), None), (MeshQuad, ElementQuad1(), ElementLineP0()), (MeshQuad, ElementQuad1(), ElementLineP1()), (MeshQuad, ElementQuad2(), ElementLineP2()), (MeshTet, ElementTetP1(), ElementTriP0()), (MeshTet, ElementTetP2(), ElementTriP2()), (MeshHex, ElementHex1(), ElementQuad0()), (MeshHex, ElementHex1(), ElementQuad1()), (MeshHex, ElementHex2(), ElementQuad2()), ]) def test_trace(mtype, e1, e2): m = mtype().refined(3) # use the boundary where last coordinate is zero basis = FacetBasis( m, e1, facets=m.facets_satisfying(lambda x: x[x.shape[0] - 1] == 0.0))
class TestIncompatibleMeshElement(TestCase): def runTest(self): with self.assertRaises(ValueError): m = MeshTri() e = ElementTetP2() basis = InteriorBasis(m, e) @pytest.mark.parametrize("mtype,e1,e2", [ (MeshTri, ElementTriP1(), ElementTriP0()), (MeshTri, ElementTriP1(), ElementTriP1()), (MeshTri, ElementTriP2(), ElementTriP1()), (MeshTri, ElementTriP2(), ElementTriP2()), (MeshTri, ElementTriP2(), None), (MeshQuad, ElementQuad1(), ElementQuad0()), (MeshQuad, ElementQuad1(), ElementQuad1()), (MeshQuad, ElementQuad2(), ElementQuad2()), (MeshTet, ElementTetP1(), ElementTetP0()), (MeshTet, ElementTetP2(), ElementTetP2()), (MeshHex, ElementHex1(), ElementHex0()), (MeshHex, ElementHex1(), ElementHex1()), (MeshHex, ElementHex2(), ElementHex2()), ]) def test_trace(mtype, e1, e2): m = mtype().refined(3) # use the boundary where last coordinate is zero basis = FacetBasis( m, e1, facets=m.facets_satisfying(lambda x: x[x.shape[0] - 1] == 0.0))
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): 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,
def mapping(self): return MappingIsoparametric(self, ElementQuad1(), ElementLineP1())