def test_radius_ratio_min_radius_ratio_max():
mesh1d = UnitIntervalMesh(MPI.comm_self, 4)
x = mesh1d.geometry.points
x[4] = mesh1d.geometry.points[3]
# Create 2D mesh with one equilateral triangle
mesh2d = RectangleMesh(
MPI.comm_world,
[numpy.array([0.0, 0.0, 0.0]),
numpy.array([1.0, 1.0, 0.0])], [1, 1], CellType.Type.triangle,
cpp.mesh.GhostMode.none, 'left')
x = mesh2d.geometry.points
x[3, :2] += 0.5 * (sqrt(3.0) - 1.0)
# Create 3D mesh with regular tetrahedron and degenerate cells
mesh3d = UnitCubeMesh(MPI.comm_self, 1, 1, 1)
x = mesh3d.geometry.points
x[6][0] = 1.0
x[3][1] = 0.0
rmin, rmax = MeshQuality.radius_ratio_min_max(mesh1d)
assert round(rmin - 0.0, 7) == 0
assert round(rmax - 1.0, 7) == 0
rmin, rmax = MeshQuality.radius_ratio_min_max(mesh2d)
assert round(rmin - 2.0 * sqrt(2.0) / (2.0 + sqrt(2.0)), 7) == 0
assert round(rmax - 1.0, 7) == 0
rmin, rmax = MeshQuality.radius_ratio_min_max(mesh3d)
assert round(rmin - 0.0, 7) == 0
assert round(rmax - 1.0, 7) == 0
def test_radius_ratio_tetrahedron_min_max():
# Create mesh, collpase and compute min ratio
mesh = UnitCubeMesh(MPI.comm_world, 12, 12, 12)
rmin, rmax = MeshQuality.radius_ratio_min_max(mesh)
assert rmax <= rmax
x = mesh.geometry.points
x[:, 0] *= 0.0
rmin, rmax = MeshQuality.radius_ratio_min_max(mesh)
assert round(rmax - 0.0, 7) == 0
assert round(rmax - 0.0, 7) == 0
def test_radius_ratio_triangle():
# Create mesh and compute rations
mesh = UnitSquareMesh(MPI.comm_world, 12, 12)
ratios = MeshQuality.radius_ratios(mesh)
for c in Cells(mesh):
assert round(ratios[c] - 0.828427124746, 7) == 0
def test_radius_ratio_tetrahedron():
# Create mesh and compute ratios
mesh = UnitCubeMesh(MPI.comm_world, 14, 14, 14)
ratios = MeshQuality.radius_ratios(mesh)
for c in Cells(mesh):
assert round(ratios[c] - 0.717438935214, 7) == 0
def test_HarmonicSmoothing():
# Create some mesh and its boundary
mesh = UnitSquareMesh(10, 10)
boundary = BoundaryMesh(mesh, 'exterior')
# Move boundary
disp = Expression(("0.3*x[0]*x[1]", "0.5*(1.0-x[1])"))
ALE.move(boundary, disp)
# Move mesh according to given boundary
ALE.move(mesh, boundary)
# Check that new boundary topology corresponds to given one
boundary_new = BoundaryMesh(mesh, 'exterior')
assert boundary.topology().hash() == boundary_new.topology().hash()
# Check that coordinates are almost equal
err = sum(sum(abs(boundary.coordinates() \
- boundary_new.coordinates()))) / mesh.num_vertices()
print("Current CG solver produced error in boundary coordinates", err)
assert round(err - 0.0, 5) == 0
# Check mesh quality
magic_number = 0.35
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
assert rmin > magic_number
def test_HarmonicSmoothing():
# Create some mesh and its boundary
mesh = UnitSquareMesh(10, 10)
boundary = BoundaryMesh(mesh, 'exterior')
# Move boundary
disp = Expression(("0.3*x[0]*x[1]", "0.5*(1.0-x[1])"))
ALE.move(boundary, disp)
# Move mesh according to given boundary
ALE.move(mesh, boundary)
# Check that new boundary topology corresponds to given one
boundary_new = BoundaryMesh(mesh, 'exterior')
assert boundary.topology().hash() == boundary_new.topology().hash()
# Check that coordinates are almost equal
err = sum(sum(abs(boundary.coordinates() \
- boundary_new.coordinates()))) / mesh.num_vertices()
print("Current CG solver produced error in boundary coordinates", err)
assert round(err - 0.0, 5) == 0
# Check mesh quality
magic_number = 0.35
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
assert rmin > magic_number
def test_HarmonicSmoothing(self):
print ""
print "Testing HarmonicSmoothing::move(Mesh& mesh, " \
"const BoundaryMesh& new_boundary)"
# Create some mesh and its boundary
mesh = UnitSquareMesh(10, 10)
boundary = BoundaryMesh(mesh, 'exterior')
# Move boundary
disp = Expression(("0.3*x[0]*x[1]", "0.5*(1.0-x[1])"))
boundary.move(disp)
# Move mesh according to given boundary
mesh.move(boundary)
# Check that new boundary topology corresponds to given one
boundary_new = BoundaryMesh(mesh, 'exterior')
self.assertEqual(boundary.topology().hash(),
boundary_new.topology().hash())
# Check that coordinates are almost equal
err = sum(sum(abs(boundary.coordinates() \
- boundary_new.coordinates()))) / mesh.num_vertices()
print "Current CG solver produced error in boundary coordinates", err
self.assertAlmostEqual(err, 0.0, places=5)
# Check mesh quality
magic_number = 0.35
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
self.assertTrue(rmin > magic_number)
def test_HarmonicSmoothing(self):
print ""
print "Testing HarmonicSmoothing::move(Mesh& mesh, " \
"const BoundaryMesh& new_boundary)"
# Create some mesh and its boundary
mesh = UnitSquareMesh(10, 10)
boundary = BoundaryMesh(mesh, 'exterior')
# Move boundary
disp = Expression(("0.3*x[0]*x[1]", "0.5*(1.0-x[1])"))
boundary.move(disp)
# Move mesh according to given boundary
mesh.move(boundary)
# Check that new boundary topology corresponds to given one
boundary_new = BoundaryMesh(mesh, 'exterior')
self.assertEqual(boundary.topology().hash(),
boundary_new.topology().hash())
# Check that coordinates are almost equal
err = sum(sum(abs(boundary.coordinates() \
- boundary_new.coordinates()))) / mesh.num_vertices()
print "Current CG solver produced error in boundary coordinates", err
self.assertAlmostEqual(err, 0.0, places=5)
# Check mesh quality
magic_number = 0.35
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
self.assertTrue(rmin > magic_number)
def find_low(mesh, V, Ause):
V2dm = V.dofmap()
cq2 = MeshQuality.radius_ratios(mesh)
cq = cq2.array()
indices = np.where(cq < 0.1)[0]
dof_set = []
cell_set = []
for i in indices:
cell = Cell(mesh, i)
for v in vertices(cell):
for c in cells(v):
cell_set += [c.index()]
dof_set.extend(V2dm.cell_dofs(c.index()))
bad_set = list(set(dof_set))
bad_cells = list(set(cell_set))
# print('BAD CELLS=', bad_cells)
# print(len(bad_cells))
# print('BAD DOFS=', bad_dofs)
# print(len(bad_dofs))
# check redundancy
re_dofs = []
for d1 in bad_set:
for d2 in bad_set:
if Ause[d1, d2] != 0:
re_dofs.append(d2)
bad_dofs = list(set(re_dofs))
return bad_dofs
def test_ale(self):
print ""
print "Testing ALE::move(Mesh& mesh0, const Mesh& mesh1)"
# Create some mesh
mesh = UnitSquareMesh(4, 5)
# Make some cell function
# FIXME: Initialization by array indexing is probably
# not a good way for parallel test
cellfunc = CellFunction('size_t', mesh)
cellfunc.array()[0:4] = 0
cellfunc.array()[4:] = 1
# Create submeshes - this does not work in parallel
submesh0 = SubMesh(mesh, cellfunc, 0)
submesh1 = SubMesh(mesh, cellfunc, 1)
# Move submesh0
disp = Constant(("0.1", "-0.1"))
submesh0.move(disp)
# Move and smooth submesh1 accordignly
submesh1.move(submesh0)
# Move mesh accordingly
parent_vertex_indices_0 = \
submesh0.data().array('parent_vertex_indices', 0)
parent_vertex_indices_1 = \
submesh1.data().array('parent_vertex_indices', 0)
mesh.coordinates()[parent_vertex_indices_0[:]] = \
submesh0.coordinates()[:]
mesh.coordinates()[parent_vertex_indices_1[:]] = \
submesh1.coordinates()[:]
# If test passes here then it is probably working
# Check for cell quality for sure
magic_number = 0.28
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
self.assertTrue(rmin > magic_number)
def test_ale(self):
print ""
print "Testing ALE::move(Mesh& mesh0, const Mesh& mesh1)"
# Create some mesh
mesh = UnitSquareMesh(4, 5)
# Make some cell function
# FIXME: Initialization by array indexing is probably
# not a good way for parallel test
cellfunc = CellFunction('size_t', mesh)
cellfunc.array()[0:4] = 0
cellfunc.array()[4:] = 1
# Create submeshes - this does not work in parallel
submesh0 = SubMesh(mesh, cellfunc, 0)
submesh1 = SubMesh(mesh, cellfunc, 1)
# Move submesh0
disp = Constant(("0.1", "-0.1"))
submesh0.move(disp)
# Move and smooth submesh1 accordignly
submesh1.move(submesh0)
# Move mesh accordingly
parent_vertex_indices_0 = \
submesh0.data().array('parent_vertex_indices', 0)
parent_vertex_indices_1 = \
submesh1.data().array('parent_vertex_indices', 0)
mesh.coordinates()[parent_vertex_indices_0[:]] = \
submesh0.coordinates()[:]
mesh.coordinates()[parent_vertex_indices_1[:]] = \
submesh1.coordinates()[:]
# If test passes here then it is probably working
# Check for cell quality for sure
magic_number = 0.28
rmin = MeshQuality.radius_ratio_min_max(mesh)[0]
self.assertTrue(rmin > magic_number)
def test_dihedral_angles_min_max():
# Create 3D mesh with regular tetrahedron
mesh = UnitCubeMesh(MPI.comm_world, 2, 2, 2)
dang_min, dang_max = MeshQuality.dihedral_angles_min_max(mesh)
assert round(dang_min * (180 / pi) - 45.0) == 0
assert round(dang_max * (180 / pi) - 90.0) == 0
