def runTest(self): m = MeshTet() # default mesh has all edges on the boundary self.assertEqual(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) * 8 (per cube face) # = 72 edges self.assertTrue(len(m.refined().boundary_edges()) == 72)
def runTest(self): m1 = MeshTet() m2 = m1.mirrored((1, 0, 0)) m3 = m1.mirrored((0, 1, 0)) m4 = m1.mirrored((0, 0, 1)) m = m1 + m2 + m3 + m4 self.assertEqual(m.nvertices, 20) self.assertEqual(m.nelements, 20)
def test_adaptive_splitting_3d_5(): # random refine m = MeshTet() np.random.seed(1337) for itr in range(10): m = m.refined( np.unique( np.random.randint(0, m.t.shape[1], size=int(0.3 * m.t.shape[1])))) assert m.is_valid()
class ConvergenceTetP2(ConvergenceTetP1): rateL2 = 3.23 rateH1 = 1.94 eps = 0.01 def create_basis(self, m): e = ElementTetP2() return InteriorBasis(m, e) def setUp(self): self.mesh = MeshTet() self.mesh.refine(1)
class ConvergenceTetP1(ConvergenceQ1): rateL2 = 2.0 rateH1 = 1.0 eps = 0.13 def create_basis(self, m): e = ElementTetP1() return InteriorBasis(m, e) def setUp(self): self.mesh = MeshTet() self.mesh.refine(2)
class ConvergenceRaviartThomas3D(ConvergenceRaviartThomas): rateL2 = .5 rateHdiv = 1.0 eps = 0.1 Hdivbound = 0.3 L2bound = 0.05 def create_basis(self, m): e = ElementTetRT0() e0 = ElementTetP0() return (InteriorBasis(m, e, intorder=2), InteriorBasis(m, e0, intorder=2)) def setUp(self): self.mesh = MeshTet() self.mesh.refine(1)
def test_adaptive_splitting_3d_3(): # adaptively refine one face of a cube, check that the mesh parameter h # is approximately linear w.r.t to distance from the face m = MeshTet.init_tensor(np.linspace(0, 1, 3), np.linspace(0, 1, 3), np.linspace(0, 1, 3)) for itr in range(15): m = m.refined(m.f2t[0, m.facets_satisfying(lambda x: x[0] == 0)]) @LinearForm def hproj(v, w): return w.h * v basis = Basis(m, ElementTetP1()) h = projection(hproj, basis) funh = basis.interpolator(h) xs = np.vstack(( np.linspace(0, .5, 20), np.zeros(20) + .5, np.zeros(20) + .5, )) hs = funh(xs) assert np.max(np.abs(hs - xs[0])) < 0.063
def runTest(self): m1 = MeshTet() m2 = m1.mirrored((1, 0, 0)) m3 = m1.mirrored((0, 1, 0)) m4 = m1.mirrored((0, 0, 1)) m = m1 + m2 + m3 + m4 self.assertEqual(m.nvertices, 20) self.assertEqual(m.nelements, 20) m = MeshTri.init_tensor( np.linspace(1, 2, 2), np.linspace(1, 2, 2), ) m = m + m.mirrored((0, 1), (2, 1)) self.assertEqual(len(m.boundary_facets()), 6) self.assertEqual(m.nvertices, 6)
def runTest(self): with self.assertRaises(Exception): # point belonging to no element MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T, np.array([[0, 1, 2]]).T) with self.assertRaises(Exception): # wrong size inputs (t not matching to Mesh type) MeshTet(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T, np.array([[0, 1, 2]]).T) with self.assertRaises(Exception): # inputting trasposes MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]), np.array([[0, 1, 2], [1, 2, 3]])) with self.assertRaises(Exception): # floats in element connectivity MeshTri(np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).T, np.array([[0.0, 1.0, 2.0], [1.0, 2.0, 3.0]]).T)
def runTest(self): # submeshes examples = Path(__file__).parents[1] / 'docs' / 'examples' m = MeshTet.load(str(examples / 'box.msh')) self.assertTrue((m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1)).all()) self.assertTrue((m.boundaries['back'] == m.facets_satisfying(lambda x: x[2] == 0)).all()) self.assertTrue((m.boundaries['front'] == m.facets_satisfying(lambda x: x[2] == 1)).all()) m = MeshTri.load(str(examples / 'square.msh')) self.assertTrue((m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1)).all()) self.assertTrue((m.boundaries['left'] == m.facets_satisfying(lambda x: x[0] == 0)).all()) self.assertTrue((m.boundaries['right'] == m.facets_satisfying(lambda x: x[0] == 1)).all())
def test_adaptive_splitting_3d_4(): # check that the same mesh is reproduced by any future versions m = MeshTet.init_tensor(np.linspace(0, 1, 2), np.linspace(0, 1, 2), np.linspace(0, 1, 2)) m = m.refined(m.f2t[0, m.facets_satisfying(lambda x: x[0] == 0)]) assert_array_equal( m.p, np.array([[0., 0., 1., 1., 0., 0., 1., 1., 0.5], [0., 1., 0., 1., 0., 1., 0., 1., 0.5], [0., 0., 0., 0., 1., 1., 1., 1., 0.5]])) assert_array_equal( m.t, np.array([[5, 3, 3, 5, 6, 6, 1, 4, 1, 2, 2, 4], [0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7], [1, 1, 2, 4, 2, 4, 5, 5, 3, 3, 6, 6], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]]))
def runTest(self): # submeshes m = MeshTet.load(MESH_PATH / 'box.msh') self.assertTrue( (m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1) ).all()) self.assertTrue( (m.boundaries['back'] == m.facets_satisfying(lambda x: x[2] == 0) ).all()) self.assertTrue( (m.boundaries['front'] == m.facets_satisfying(lambda x: x[2] == 1) ).all()) m = MeshTri.load(MESH_PATH / 'square.msh') self.assertTrue( (m.boundaries['top'] == m.facets_satisfying(lambda x: x[1] == 1) ).all()) self.assertTrue( (m.boundaries['left'] == m.facets_satisfying(lambda x: x[0] == 0) ).all()) self.assertTrue( (m.boundaries['right'] == m.facets_satisfying(lambda x: x[0] == 1) ).all())
if self.test_integrate_volume: # by Gauss theorem this integrates to one for itr in range(m.p.shape[0]): @LinearForm def linf(v, w): return w.n[itr] * v b = asm(linf, basis) self.assertAlmostEqual(b @ m.p[itr, :], 1.0, places=5) 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):
def setUp(self): self.mesh = MeshTet() self.mesh.refine(1)
m = MeshTet() np.random.seed(1337) for itr in range(10): m = m.refined( np.unique( np.random.randint(0, m.t.shape[1], size=int(0.3 * m.t.shape[1])))) assert m.is_valid() @pytest.mark.parametrize( "m,seed", [ (MeshTet(), 0), (MeshTet(), 1), # problems (MeshTet(), 2), (MeshTet(), 3), (MeshTet().refined(), 10), ]) def test_adaptive_random_splitting(m, seed): np.random.seed(seed) points = np.hstack((m.p, np.random.rand(m.p.shape[0], 100))) tri = Delaunay(points.T) m = type(m)(points, tri.simplices.T) assert m.is_valid() for itr in range(3): M = m.refined(
def setUp(self): self.mesh = MeshTet().refined(1)
boundary_integral.assemble(sfbasis, u=m.p[0] * m.p[1]), boundary_integral.assemble(fbasis, u=m.p[0] * m.p[1]), ) @pytest.mark.parametrize( "m, e, facets, fun", [ ( MeshTri.load(MESH_PATH / 'interface.msh'), ElementTriP1(), 'interfacee', lambda m: m.p[1], ), ( MeshTet.load(MESH_PATH / 'cuubat.msh'), ElementTetP1(), 'interface', lambda m: m.p[0], ) ] ) def test_oriented_interface_integral(m, e, facets, fun): fb = FacetBasis(m, e, facets=facets) assert_almost_equal( Functional(lambda w: dot(w.fun.grad, w.n)).assemble(fb, fun=fun(m)), 1.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): return w['random']**2
def test_adaptive_splitting_3d(): m = MeshTet() for itr in range(10): M = m.refined([itr, itr + 1, itr + 2]) assert M.is_valid() m = M
def test_adaptive_splitting_3d_1(): m = MeshTet() for itr in range(50): m = m.refined([itr]) assert m.is_valid()
def test_adaptive_splitting_3d_2(): m = MeshTet() for itr in range(5): m = m.refined(np.arange(m.nelements, dtype=np.int64)) assert m.is_valid()