def initialize_meshes(self): m0 = MeshHex() m = MeshHex( np.array([[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [1., 0.7, 0.7], [0., 1., 1.], [1., 0., 1.], [1., 1., 0.], [1., 1., 1.]]).T, m0.t) return m
def runTest(self): m = MeshHex() # default mesh has all edges on the boundary self.assertTrue(len(m.boundary_edges()) == m.edges.shape[1]) # check that there is a correct amount of boundary edges: # 12 (cube edges) * 2 (per cube edge) # + 6 (cube faces) * 4 (per cube face) # = 48 edges self.assertEqual(len(m.refined().boundary_edges()), 48)
class ConvergenceHexS2(ConvergenceQ1): rateL2 = 3.05 rateH1 = 2.21 eps = 0.02 def create_basis(self, m): e = ElementHexS2() return InteriorBasis(m, e) def setUp(self): self.mesh = MeshHex() self.mesh.refine(1)
class ConvergenceHex1(ConvergenceQ1): rateL2 = 2.0 rateH1 = 1.0 eps = 0.11 def create_basis(self, m): e = ElementHex1() return InteriorBasis(m, e) def setUp(self): self.mesh = MeshHex() self.mesh.refine(2)
def runTest(self): # Mesh.remove_elements m = MeshTri() m.refine() M = m.remove_elements(np.array([0])) self.assertEqual(M.t.shape[1], 7) # Mesh.define_boundary m.define_boundary('foo', lambda x: x[0] == 0.) self.assertEqual(m.boundaries['foo'].size, 2) # Mesh.define_boundary (internal) m.define_boundary('bar', lambda x: x[0] == 1. / 2, boundaries_only=False) self.assertEqual(m.boundaries['bar'].size, 2) # Mesh.scale, Mesh.translate m = MeshHex() m.scale(0.5) m.translate((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)
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)
def runTest(self): m = MeshHex() # check that these assemble to the same matrix ec = ElementHex1() * ElementHex1() * ElementHex1() ev = ElementVectorH1(ElementHex1()) basisc = Basis(m, ec) basisv = Basis(m, ev) @BilinearForm def bilinf_ev(u, v, w): from skfem.helpers import dot return dot(u, v) @BilinearForm def bilinf_ec(ux, uy, uz, vx, vy, vz, w): return ux * vx + uy * vy + uz * vz Kv = asm(bilinf_ev, basisv) Kc = asm(bilinf_ec, basisc) self.assertAlmostEqual(np.sum(np.sum((Kv - Kc).todense())), 0.)
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): case = (MeshHex(), ElementHexS2()) intorder = 3 test_integrate_volume = False class NormalVectorTestHex2(NormalVectorTestTri): case = (MeshHex(), ElementHex2()) intorder = 3 test_integrate_volume = False
( MeshTri().refined(2), MeshTri1DG, ElementTriP2, lambda x: x[0] == 0, lambda x: x[0] == 1, ), ( MeshTri().refined(2), MeshTri1DG, ElementTriP2, lambda x: x[1] == 0, lambda x: x[1] == 1, ), ( MeshHex().refined(4), MeshHex1DG, ElementHex1, lambda x: x[1] == 0, lambda x: x[1] == 1, ), ( MeshHex().refined(3), MeshHex1DG, ElementHex2, lambda x: x[2] == 0, lambda x: x[2] == 1, ), ]) def test_periodic_mesh_assembly(m, mdgtype, etype, check1, check2): def _sort(ix):
def setUp(self): self.mesh = MeshHex().refined(1)
def setUp(self): self.mesh = MeshHex().refined(2).to_meshtet()
Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=fun(m)), 1.0, ) @pytest.mark.parametrize( "m, e, facets, normal", [ ( MeshTri().refined(2) + MeshTri().translated((1.0, 0.0)).refined(2), ElementTriP1(), lambda x: x[0] == 1.0, np.array([1, 0]), ), ( MeshHex().refined(2) + MeshHex().translated((1., 0., 0.)).refined(2), ElementHex1(), lambda x: x[0] == 1.0, np.array([1, 0, 0]), ), ] ) def test_oriented_interface_integral2(m, e, facets, normal): fb = FacetBasis(m, e, facets=m.facets_satisfying(facets, normal=normal)) assert_almost_equal( Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=m.p[0]), 1.0, )
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): return w['random']**2 basis = InteriorBasis(m, e) basisdg = InteriorBasis(m, edg) assert_allclose( square.assemble(basis, random=basis.interpolate(basis.zeros() + 1)),
class TestFinder1DLinspaced(TestCase): def runTest(self): for itr in range(5): finder = (MeshLine(np.linspace(0, 1, 2**itr + 1)).element_finder()) self.assertEqual(finder(np.array([0.999]))[0], 2**itr - 1) self.assertEqual(finder(np.array([0.001]))[0], 0) @pytest.mark.parametrize("m", [ MeshTri.init_circle(), MeshQuad.init_tensor([0, 1, 3], [0, 1, 3]), MeshTet().refined(3), MeshHex.init_tensor([0, 1, 3], [0, 1, 3], [0, 1, 3]), ]) def test_smoothed(m): M = m.smoothed() assert M.is_valid() # points have moved? assert np.linalg.norm((M.p - m.p)**2) > 0 @pytest.mark.parametrize("m", [ MeshTri(), MeshTet(), ]) def test_oriented(m): M = m.oriented() assert np.sum(m.orientation() < 0) > 0
def setUp(self): self.mesh = MeshHex() self.mesh.refine(1)
def createBasis(self): m = MeshHex().refined(3) self.fbasis = FacetBasis(m, ElementHex2()) self.boundary_area = 6.000