def test_padded_bbox(padding):
"""Test collision between two meshes separated by a distance of
epsilon, and check if padding the mesh creates a possible
collision"""
eps = 1e-12
x0 = np.array([0, 0, 0])
x1 = np.array([1, 1, 1 - eps])
mesh_0 = create_box(MPI.COMM_WORLD, [x0, x1], [1, 1, 2], CellType.hexahedron)
x2 = np.array([0, 0, 1 + eps])
x3 = np.array([1, 1, 2])
mesh_1 = create_box(MPI.COMM_WORLD, [x2, x3], [1, 1, 2], CellType.hexahedron)
if padding:
pad = eps
else:
pad = 0
bbox_0 = BoundingBoxTree(mesh_0, mesh_0.topology.dim, padding=pad)
bbox_1 = BoundingBoxTree(mesh_1, mesh_1.topology.dim, padding=pad)
collisions = compute_collisions(bbox_0, bbox_1)
if padding:
assert len(collisions) == 1
# Check that the colliding elements are separated by a distance
# 2*epsilon
element_0 = extract_geometricial_data(mesh_0, mesh_0.topology.dim, [collisions[0][0]])[0]
element_1 = extract_geometricial_data(mesh_1, mesh_1.topology.dim, [collisions[0][1]])[0]
distance = np.linalg.norm(compute_distance_gjk(element_0, element_1))
assert np.isclose(distance, 2 * eps)
else:
assert len(collisions) == 0
def test_submesh_cell_assembly(d, n, k, space, ghost_mode):
"""Check that assembling a form over a unit square gives the same
result as assembling over half of a 2x1 rectangle with the same
triangulation."""
if d == 2:
mesh_0 = create_unit_square(
MPI.COMM_WORLD, n, n, ghost_mode=ghost_mode)
mesh_1 = create_rectangle(
MPI.COMM_WORLD, ((0.0, 0.0), (2.0, 1.0)), (2 * n, n),
ghost_mode=ghost_mode)
else:
mesh_0 = create_unit_cube(
MPI.COMM_WORLD, n, n, n, ghost_mode=ghost_mode)
mesh_1 = create_box(
MPI.COMM_WORLD, ((0.0, 0.0, 0.0), (2.0, 1.0, 1.0)),
(2 * n, n, n), ghost_mode=ghost_mode)
A_mesh_0 = assemble(mesh_0, space, k)
edim = mesh_1.topology.dim
entities = locate_entities(mesh_1, edim, lambda x: x[0] <= 1.0)
submesh = create_submesh(mesh_1, edim, entities)[0]
A_submesh = assemble(submesh, space, k)
# FIXME Would probably be better to compare entries rather than just
# norms
assert(np.isclose(A_mesh_0.norm(), A_submesh.norm()))
dofs_block = V.dofmap.list.array
x0, x1, x2 = x[dofs_block, 0], x[dofs_block, 1], x[dofs_block, 2]
basis[3][dofs[0]] = -x1
basis[3][dofs[1]] = x0
basis[4][dofs[0]] = x2
basis[4][dofs[2]] = -x0
basis[5][dofs[2]] = x1
basis[5][dofs[1]] = -x2
la.orthonormalize(ns)
assert la.is_orthonormal(ns)
return PETSc.NullSpace().create(vectors=ns)
mesh = create_box(MPI.COMM_WORLD,
[np.array([0.0, 0.0, 0.0]),
np.array([2.0, 1.0, 1.0])], [12, 12, 12],
CellType.tetrahedron, GhostMode.shared_facet)
# Rotation rate and mass density
omega = 300.0
rho = 10.0
# Loading due to centripetal acceleration (rho*omega^2*x_i)
x = SpatialCoordinate(mesh)
f = as_vector((rho * omega**2 * x[0], rho * omega**2 * x[1], 0.0))
# Elasticity parameters
E = 1.0e9
nu = 0.0
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
])
@pytest.mark.parametrize("degree", [1, 2])
def test_nullspace_orthogonal(mesh, degree):
"""Test that null spaces orthogonalisation"""
V = VectorFunctionSpace(mesh, ('Lagrange', degree))
nullspace = build_elastic_nullspace(V)
assert not la.is_orthonormal(nullspace)
la.orthonormalize(nullspace)
assert la.is_orthonormal(nullspace)
@pytest.mark.parametrize("mesh", [
create_unit_square(MPI.COMM_WORLD, 12, 13),
create_box(MPI.COMM_WORLD,
[np.array([0.8, -0.2, 1.2]),
np.array([3.0, 11.0, -5.0])], [12, 18, 25],
cell_type=CellType.tetrahedron,
ghost_mode=GhostMode.none),
])
@pytest.mark.parametrize("degree", [1, 2])
def test_nullspace_check(mesh, degree):
V = VectorFunctionSpace(mesh, ('Lagrange', degree))
u, v = TrialFunction(V), TestFunction(V)
E, nu = 2.0e2, 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
def sigma(w, gdim):
return 2.0 * mu * ufl.sym(grad(w)) + lmbda * ufl.tr(
grad(w)) * ufl.Identity(gdim)
def test_create_box_prism():
mesh = create_box(MPI.COMM_WORLD, [[0., 0., 0.], [1., 1., 1.]], [2, 3, 4],
CellType.prism, GhostMode.none)
assert mesh.topology.index_map(0).size_global == 60
assert mesh.topology.index_map(3).size_global == 48
def box():
return create_box(
MPI.COMM_WORLD,
[np.array([0, 0, 0]), np.array([2, 2, 2])], [2, 2, 5],
CellType.tetrahedron, GhostMode.none)