def test_element(self):
"""
Test the creation and methods of a single element
"""
nodes = [
mesh.Node([0.0, 0.0]),
mesh.Node([1.0, 0.0]),
mesh.Node([1.0, 1.0]),
mesh.Node([0.0, 1.0])
]
for node in nodes:
self.assertEquals(node.adjacent_elements, [])
element = mesh.Element(nodes, 42)
for node in element.nodes:
self.assertEqual(len(node.adjacent_elements), 1)
self.assertEqual(node.adjacent_elements[0].id_in_frame, 42)
self.assertEqual(node.get_adjacent_element_ids(), [42])
self.assertEqual(element.get_num_nodes(), 4)
self.assertEqual(element.id_in_frame, 42)
self.assertAlmostEqual(element.calculate_area(), 1.0)
np.testing.assert_almost_equal(element.calculate_centroid(),
[0.5, 0.5])
def test_mesh_methods(self):
"""create a 2 by 2 rectangular mesh and test the number
of elements, their number of nodes, etc"""
# make some vertices
vertices = []
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([1.0, 0.0]))
vertices.append(mesh.Node([2.0, 0.0]))
vertices.append(mesh.Node([0.0, 1.0]))
vertices.append(mesh.Node([1.0, 1.0]))
vertices.append(mesh.Node([2.0, 1.0]))
vertices.append(mesh.Node([0.0, 2.0]))
vertices.append(mesh.Node([1.0, 2.0]))
vertices.append(mesh.Node([2.0, 2.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([vertices[0], vertices[1], vertices[4], vertices[3]]))
list_of_elements.append(
mesh.Element([vertices[1], vertices[2], vertices[5], vertices[4]]))
list_of_elements.append(
mesh.Element([vertices[3], vertices[4], vertices[7], vertices[6]]))
list_of_elements.append(
mesh.Element([vertices[4], vertices[5], vertices[8], vertices[7]]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
simple_mesh.assign_frame_ids_in_order()
self.assertEqual(simple_mesh.get_num_nodes(), 9)
self.assertEqual(simple_mesh.get_num_elements(), 4)
for counter, element in enumerate(simple_mesh.elements):
self.assertEqual(element.get_num_nodes(), 4)
self.assertEqual(element.id_in_frame, counter)
for counter, node in enumerate(simple_mesh.nodes):
self.assertEqual(node.id, counter)
expected_edges = np.array([[0, 1], [1, 4], [4, 3], [3, 0], [1, 2],
[2, 5], [5, 4], [4, 7], [7, 6], [6, 3],
[5, 8], [8, 7]])
edges = simple_mesh.collect_edges()
np.testing.assert_equal(edges, expected_edges)
inner_edges = simple_mesh.collect_elements_of_inner_edges()
self.assertEqual(len(inner_edges), 4)
assert (set([0, 1]) in inner_edges)
assert (set([0, 2]) in inner_edges)
assert (set([1, 3]) in inner_edges)
assert (set([2, 3]) in inner_edges)
nodes_between_element_0_and_1 = simple_mesh.get_nodes_shared_by_elements(
[0, 1])
nodes_between_element_0_and_2 = simple_mesh.get_nodes_shared_by_elements(
[0, 2])
nodes_between_element_0_and_3 = simple_mesh.get_nodes_shared_by_elements(
[0, 3])
self.assertEqual(set([1, 4]), nodes_between_element_0_and_1)
self.assertEqual(set([3, 4]), nodes_between_element_0_and_2)
self.assertEqual(set([4]), nodes_between_element_0_and_3)
simple_mesh.assign_frame_ids_in_order()
network_representation = simple_mesh.generate_network()
self.assertEqual(network_representation.number_of_nodes(), 4)
self.assertEqual(network_representation.number_of_edges(), 4)
assert (network_representation.has_edge(0, 1))
assert (network_representation.has_edge(0, 2))
assert (network_representation.has_edge(1, 3))
assert (network_representation.has_edge(2, 3))
# test width and height methods
self.assertAlmostEquals(simple_mesh.calculate_width(), 2.0)
self.assertAlmostEquals(simple_mesh.calculate_height(), 2.0)
filename = 'simple_mesh.pdf'
if os.path.exists(filename):
os.remove(filename)
simple_mesh.plot(path.join(dirname(__file__), 'output', filename))
assert (os.path.exists(path.join(dirname(__file__), 'output',
filename)))
# test the calculate total area and calculate average area methods
# as well as calculate centroid
self.assertEqual(simple_mesh.calculate_total_area(), 4.0)
self.assertEqual(simple_mesh.calculate_average_element_area(), 1.0)
np.testing.assert_almost_equal(simple_mesh.calculate_centre(),
[1.0, 1.0])
def test_remove_boundary_elements(self):
"""tests whether we can correctly remove all boundary elements in a mesh
"""
vertices = []
vertices.append(mesh.Node([-2.0, 0.0]))
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([2.0, 0.0]))
vertices.append(mesh.Node([-2.0, 2.0]))
vertices.append(mesh.Node([-1.0, 2.0]))
vertices.append(mesh.Node([0.0, 1.0]))
vertices.append(mesh.Node([1.0, 2.0]))
vertices.append(mesh.Node([2.0, 2.0]))
vertices.append(mesh.Node([-2.0, 3.0]))
vertices.append(mesh.Node([-1.0, 3.0]))
vertices.append(mesh.Node([1.0, 3.0]))
vertices.append(mesh.Node([2.0, 3.0]))
vertices.append(mesh.Node([-2.0, 5.0]))
vertices.append(mesh.Node([0.0, 4.0]))
vertices.append(mesh.Node([2.0, 5.0]))
vertices.append(mesh.Node([0.0, 5.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([
vertices[0], vertices[1], vertices[5], vertices[4], vertices[3]
]))
list_of_elements.append(
mesh.Element([
vertices[1], vertices[2], vertices[7], vertices[6], vertices[5]
]))
list_of_elements.append(
mesh.Element([vertices[3], vertices[4], vertices[9], vertices[8]]))
list_of_elements.append(
mesh.Element([
vertices[4], vertices[5], vertices[6], vertices[10],
vertices[13], vertices[9]
]))
list_of_elements.append(
mesh.Element(
[vertices[6], vertices[7], vertices[11], vertices[10]]))
list_of_elements.append(
mesh.Element([
vertices[8], vertices[9], vertices[13], vertices[15],
vertices[12]
]))
list_of_elements.append(
mesh.Element([
vertices[10], vertices[11], vertices[14], vertices[15],
vertices[13]
]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
simple_mesh.assign_frame_ids_in_order()
self.assert_(not simple_mesh.elements[3].check_if_on_boundary())
for element in simple_mesh.elements:
if element.id_in_frame != 3:
self.assert_(element.check_if_on_boundary())
simple_mesh.remove_boundary_elements()
self.assertEqual(simple_mesh.get_num_elements(), 1)
self.assertEqual(simple_mesh.get_num_nodes(), 6)
self.assertEqual(simple_mesh.elements[0].id_in_frame, 3)
for node in simple_mesh.nodes:
self.assertEqual(len(node.get_adjacent_element_ids()), 1)
# def test_copy_large_mesh(self):
# """test whether we can use deepcopy() to copy a mesh"""
#
# random_mesh = mesh.creation.generate_random_tesselation(30, 30, 0)
# random_mesh.assign_frame_ids_randomly()
#
# mesh_copy = random_mesh.copy()
#
# node_5_position = random_mesh.nodes[5].position
# self.assertNotAlmostEqual(node_5_position[0], 1.01, msg = 'randomly ran into this, just run the test again!')
# self.assertNotAlmostEqual(node_5_position[1], 1.01, msg = 'randomly ran into this, just run the test again!')
#
# for node_index, node in enumerate(random_mesh.nodes):
# np.testing.assert_almost_equal(node.position, mesh_copy.nodes[node_index].position)
# self.assertEqual(node.id, mesh_copy.nodes[node_index].id)
#
# for element_index, element in enumerate(random_mesh.elements):
# self.assertEqual(element.id_in_frame, mesh_copy.elements[element_index].id_in_frame)
# copied_element = mesh_copy.elements[element_index]
# for node_index, node in enumerate(element.nodes):
# np.testing.assert_almost_equal(node.position, mesh_copy.nodes[node_index].position)
# self.assertEqual(node.id, copied_element.nodes[node_index].id)
#
#
# mesh_copy.nodes[5].position = np.array([1.01, 1.01])
#
# self.assertNotAlmostEqual(random_mesh.nodes[5].position[0], 1.01)
# self.assertNotAlmostEqual(random_mesh.nodes[5].position[1], 1.01)
#
# frame_id_of_7th_element = random_mesh.elements[7].id_in_frame
#
# mesh_copy.elements[7].id_in_frame = 5000
#
# self.assertEqual(random_mesh.elements[7].id_in_frame, frame_id_of_7th_element)
# self.assertNotEqual(random_mesh.elements[7].id_in_frame, 5000)
#
# for node in enumerate(random_mesh.nodes):
# self.assertEquals(random_mesh.node.position, mesh_copy.node.position)
def test_divide_element_in_direction(self):
"""Test whether we can perform a division event"""
vertices = []
vertices.append(mesh.Node([-2.0, 0.0]))
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([2.0, 0.0]))
vertices.append(mesh.Node([-2.0, 2.0]))
vertices.append(mesh.Node([-1.0, 2.0]))
vertices.append(mesh.Node([0.0, 1.0]))
vertices.append(mesh.Node([1.0, 2.0]))
vertices.append(mesh.Node([2.0, 2.0]))
vertices.append(mesh.Node([-2.0, 3.0]))
vertices.append(mesh.Node([-1.0, 3.0]))
vertices.append(mesh.Node([1.0, 3.0]))
vertices.append(mesh.Node([2.0, 3.0]))
vertices.append(mesh.Node([-2.0, 5.0]))
vertices.append(mesh.Node([0.0, 4.0]))
vertices.append(mesh.Node([2.0, 5.0]))
vertices.append(mesh.Node([0.0, 5.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([
vertices[0], vertices[1], vertices[5], vertices[4], vertices[3]
]))
list_of_elements.append(
mesh.Element([
vertices[1], vertices[2], vertices[7], vertices[6], vertices[5]
]))
list_of_elements.append(
mesh.Element([vertices[3], vertices[4], vertices[9], vertices[8]]))
list_of_elements.append(
mesh.Element([
vertices[4], vertices[5], vertices[6], vertices[10],
vertices[13], vertices[9]
]))
list_of_elements.append(
mesh.Element(
[vertices[6], vertices[7], vertices[11], vertices[10]]))
list_of_elements.append(
mesh.Element([
vertices[8], vertices[9], vertices[13], vertices[15],
vertices[12]
]))
list_of_elements.append(
mesh.Element([
vertices[10], vertices[11], vertices[14], vertices[15],
vertices[13]
]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
self.assertEqual(simple_mesh.get_num_nodes(), 16)
self.assertEqual(simple_mesh.get_num_elements(), 7)
simple_mesh.assign_frame_ids_in_order()
simple_mesh.plot(
path.join(dirname(__file__), 'output', 'division_test_before.pdf'))
area_of_element_to_divide = simple_mesh.get_element_with_frame_id(
3).calculate_area()
simple_mesh.divide_element_with_frame_id_in_direction(3, [0.5, 1.0])
simple_mesh.plot(
path.join(dirname(__file__), 'output', 'division_test_after.pdf'))
self.assertEquals(
simple_mesh.get_element_with_frame_id(0).get_num_nodes(), 6)
self.assertEquals(
simple_mesh.get_element_with_frame_id(1).get_num_nodes(), 5)
self.assertEquals(
simple_mesh.get_element_with_frame_id(2).get_num_nodes(), 4)
self.assertEquals(
simple_mesh.get_element_with_frame_id(4).get_num_nodes(), 4)
self.assertEquals(
simple_mesh.get_element_with_frame_id(5).get_num_nodes(), 5)
self.assertEquals(
simple_mesh.get_element_with_frame_id(6).get_num_nodes(), 6)
first_new_node_exists = False
second_new_node_exists = False
for node in simple_mesh.nodes:
if np.allclose(node.position, [0.5, 3.5]):
first_new_node_exists = True
first_new_node = node
if np.allclose(node.position, [-0.5, 1.5]):
second_new_node_exists = True
second_new_node = node
assert (first_new_node_exists)
assert (second_new_node_exists)
self.assertEquals(len(first_new_node.adjacent_elements), 3)
self.assertEquals(len(second_new_node.adjacent_elements), 3)
daughter_element_ids = set.intersection(
set(first_new_node.get_adjacent_element_ids()),
set(second_new_node.get_adjacent_element_ids()))
self.assertEquals(len(daughter_element_ids), 2)
first_daughter_element = simple_mesh.get_element_with_frame_id(
daughter_element_ids.pop())
self.assertAlmostEqual(first_daughter_element.get_num_nodes(), 5)
second_daughter_element = simple_mesh.get_element_with_frame_id(
daughter_element_ids.pop())
self.assertAlmostEqual(second_daughter_element.get_num_nodes(), 5)
self.assertAlmostEqual(
first_daughter_element.calculate_area() +
second_daughter_element.calculate_area(),
area_of_element_to_divide)
def test_make_triangular_element_in_division(self):
"""Test whether we can perform a division event"""
vertices = []
vertices.append(mesh.Node([-2.0, 0.0]))
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([2.0, 0.0]))
vertices.append(mesh.Node([-2.0, 2.0]))
vertices.append(mesh.Node([-1.0, 2.0]))
vertices.append(mesh.Node([0.0, 1.0]))
vertices.append(mesh.Node([1.0, 2.0]))
vertices.append(mesh.Node([2.0, 2.0]))
vertices.append(mesh.Node([-2.0, 5.0]))
vertices.append(mesh.Node([0.0, 4.0]))
vertices.append(mesh.Node([2.0, 5.0]))
vertices.append(mesh.Node([0.0, 5.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([
vertices[0], vertices[1], vertices[5], vertices[4], vertices[3]
]))
list_of_elements.append(
mesh.Element([
vertices[1], vertices[2], vertices[7], vertices[6], vertices[5]
]))
list_of_elements.append(
mesh.Element([vertices[4], vertices[5], vertices[6], vertices[9]]))
list_of_elements.append(
mesh.Element([
vertices[9], vertices[11], vertices[8], vertices[3],
vertices[4]
]))
list_of_elements.append(
mesh.Element([
vertices[10], vertices[11], vertices[9], vertices[6],
vertices[7]
]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
self.assertEqual(simple_mesh.get_num_nodes(), 12)
self.assertEqual(simple_mesh.get_num_elements(), 5)
simple_mesh.assign_frame_ids_in_order()
simple_mesh.plot(
path.join(dirname(__file__), 'output',
'triangular_division_test_before.pdf'))
area_of_element_to_divide = simple_mesh.get_element_with_frame_id(
3).calculate_area()
simple_mesh.divide_element_with_frame_id_in_direction(2, [1.0, 0.0])
simple_mesh.plot(
path.join(dirname(__file__), 'output',
'triangular_division_test_after.pdf'))
self.assertEquals(
simple_mesh.get_element_with_frame_id(0).get_num_nodes(), 5)
self.assertEquals(
simple_mesh.get_element_with_frame_id(1).get_num_nodes(), 5)
self.assertEquals(
simple_mesh.get_element_with_frame_id(3).get_num_nodes(), 6)
self.assertEquals(
simple_mesh.get_element_with_frame_id(4).get_num_nodes(), 6)
self.assertEquals(
simple_mesh.get_element_with_frame_id(5).get_num_nodes(), 3)
self.assertEquals(
simple_mesh.get_element_with_frame_id(6).get_num_nodes(), 5)
def test_kill_element(self):
"""Test whether we can perform a death event"""
vertices = []
vertices.append(mesh.Node([-2.0, 0.0]))
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([2.0, 0.0]))
vertices.append(mesh.Node([-2.0, 2.0]))
vertices.append(mesh.Node([-1.0, 2.0]))
vertices.append(mesh.Node([0.0, 1.0]))
vertices.append(mesh.Node([1.0, 2.0]))
vertices.append(mesh.Node([2.0, 2.0]))
vertices.append(mesh.Node([-2.0, 3.0]))
vertices.append(mesh.Node([-1.0, 3.0]))
vertices.append(mesh.Node([1.0, 3.0]))
vertices.append(mesh.Node([2.0, 3.0]))
vertices.append(mesh.Node([-2.0, 5.0]))
vertices.append(mesh.Node([0.0, 4.0]))
vertices.append(mesh.Node([2.0, 5.0]))
vertices.append(mesh.Node([0.0, 5.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([
vertices[0], vertices[1], vertices[5], vertices[4], vertices[3]
]))
list_of_elements.append(
mesh.Element([
vertices[1], vertices[2], vertices[7], vertices[6], vertices[5]
]))
list_of_elements.append(
mesh.Element([vertices[3], vertices[4], vertices[9], vertices[8]]))
list_of_elements.append(
mesh.Element([
vertices[4], vertices[5], vertices[6], vertices[10],
vertices[13], vertices[9]
]))
list_of_elements.append(
mesh.Element(
[vertices[6], vertices[7], vertices[11], vertices[10]]))
list_of_elements.append(
mesh.Element([
vertices[8], vertices[9], vertices[13], vertices[15],
vertices[12]
]))
list_of_elements.append(
mesh.Element([
vertices[10], vertices[11], vertices[14], vertices[15],
vertices[13]
]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
self.assertEqual(simple_mesh.get_num_nodes(), 16)
self.assertEqual(simple_mesh.get_num_elements(), 7)
simple_mesh.assign_frame_ids_in_order()
simple_mesh.plot(
path.join(dirname(__file__), 'output', 'death_test_before.pdf'))
simple_mesh.kill_element_with_frame_id(3)
simple_mesh.plot(
path.join(dirname(__file__), 'output', 'death_test_after.pdf'))
self.assertEqual(simple_mesh.get_num_nodes(), 11)
self.assertEqual(simple_mesh.get_num_elements(), 6)
self.assertEquals(
simple_mesh.get_element_with_frame_id(0).get_num_nodes(), 4)
self.assertEquals(
simple_mesh.get_element_with_frame_id(1).get_num_nodes(), 4)
self.assertEquals(
simple_mesh.get_element_with_frame_id(2).get_num_nodes(), 3)
self.assertEquals(
simple_mesh.get_element_with_frame_id(4).get_num_nodes(), 3)
self.assertEquals(
simple_mesh.get_element_with_frame_id(5).get_num_nodes(), 4)
self.assertEquals(
simple_mesh.get_element_with_frame_id(6).get_num_nodes(), 4)
new_node_exists = False
for node in simple_mesh.nodes:
if np.allclose(node.position, [0.0, 2.5]):
new_node_exists = True
new_node = node
break
assert (new_node_exists)
self.assertEquals(len(new_node.adjacent_elements), 6)
# We want to test that the new node got added in the right order to all elements. If it isn't added at the right position to the
# elements, the elements will have a different area, and hence their total area will not add up to the total area
# that the mesh should have.
self.assertAlmostEqual(simple_mesh.calculate_total_area(), 20.0)
def test_t1_swap(self):
"""Test whether we can perform a t1 swap"""
vertices = []
vertices.append(mesh.Node([0.0, 0.0]))
vertices.append(mesh.Node([1.0, 1.0]))
vertices.append(mesh.Node([0.0, 2.0]))
vertices.append(mesh.Node([-1.0, 1.0]))
vertices.append(mesh.Node([3.0, 2.5]))
vertices.append(mesh.Node([-3.0, 2.5]))
vertices.append(mesh.Node([0.0, 3.0]))
vertices.append(mesh.Node([1.0, 4.0]))
vertices.append(mesh.Node([-1.0, 4.0]))
vertices.append(mesh.Node([0.0, 5.0]))
# make some elements
list_of_elements = []
list_of_elements.append(
mesh.Element([vertices[0], vertices[1], vertices[2], vertices[3]]))
list_of_elements.append(
mesh.Element([
vertices[1], vertices[4], vertices[7], vertices[6], vertices[2]
]))
list_of_elements.append(
mesh.Element([
vertices[3], vertices[2], vertices[6], vertices[8], vertices[5]
]))
list_of_elements.append(
mesh.Element([vertices[6], vertices[7], vertices[9], vertices[8]]))
simple_mesh = mesh.Mesh(vertices, list_of_elements)
self.assertEqual(simple_mesh.get_num_nodes(), 10)
self.assertEqual(simple_mesh.get_num_elements(), 4)
simple_mesh.assign_frame_ids_in_order()
simple_mesh.plot(
path.join(dirname(__file__), 'output', 't1_swap_before.pdf'))
simple_mesh.perform_t1_swap(2, 6)
for element in simple_mesh.elements:
if element.id_in_frame in [1, 2]:
self.assertEqual(element.get_num_nodes(), 4)
if element.id_in_frame in [0, 3]:
self.assertEqual(element.get_num_nodes(), 5)
distance_between_the_new_nodes = np.linalg.norm(
simple_mesh.nodes[2].position - simple_mesh.nodes[6].position)
centre_of_the_two_nodes = np.mean(np.vstack(
(simple_mesh.nodes[2].position, simple_mesh.nodes[6].position)),
axis=0)
# self.assert_( simple_mesh.nodes[2].get_adjacent_element_ids()
simple_mesh.plot(
path.join(dirname(__file__), 'output', 't1_swap_after.pdf'))
self.assertAlmostEqual(distance_between_the_new_nodes, 0.2)
np.testing.assert_almost_equal(centre_of_the_two_nodes, [0.0, 2.5])
for local_index, node in enumerate(simple_mesh.elements[0].nodes):
if np.allclose(node.position, [0.1, 2.5]):
np.testing.assert_almost_equal(
simple_mesh.elements[0].nodes[(local_index + 1) %
5].position, [-0.1, 2.5])
self.assert_(0 in node.get_adjacent_element_ids())
self.assert_(1 in node.get_adjacent_element_ids())
self.assert_(3 in node.get_adjacent_element_ids())
self.assert_(2 not in node.get_adjacent_element_ids())
break
else:
self.assertNotEqual(local_index, 4)
for local_index, node in enumerate(simple_mesh.elements[3].nodes):
if np.allclose(node.position, [-0.1, 2.5]):
np.testing.assert_almost_equal(
simple_mesh.elements[3].nodes[(local_index + 1) %
5].position, [0.1, 2.5])
self.assert_(2 in node.get_adjacent_element_ids())
self.assert_(0 in node.get_adjacent_element_ids())
self.assert_(3 in node.get_adjacent_element_ids())
self.assert_(1 not in node.get_adjacent_element_ids())
break
else:
self.assertNotEqual(local_index, 4)