def test_depth(self):
#
# Generate forest
#
forest = Forest([Tree(2), Tree(2)])
#
# Split tree 0 three times
#
tree = forest.get_child(0)
for dummy in range(3):
tree.split()
tree = tree.get_child(0)
# Check that depth is 3
self.assertEqual(forest.depth(), 3)
# Remove split tree and verify that depth is 0
forest.remove_tree(0)
self.assertEqual(forest.depth(), 0)
def test_refine(self):
# =====================================================================
# Simple Refineement
# =====================================================================
# Define a new forest with two binary trees
forest = Forest([Tree(2), Tree(2)])
# Refine the forest indiscriminantly
forest.refine()
# Check wether the trees have been split
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
# =====================================================================
# Refinement Label
# =====================================================================
# Mark second tree and refine only by its label
forest.get_child(1).mark(1)
forest.refine(refinement_flag=1)
# Nothing should have happened (because child is not a leaf)
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
forest.get_child(1).get_child(1).mark(1)
forest.refine(refinement_flag=1)
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 8)
# =====================================================================
# Refinement of subforest
# =====================================================================
forest = Forest([Tree(2), Tree(2)])
forest.refine()
# Define subforest
forest.get_child(0).get_child(0).mark(1)
forest.root_subtrees(1)
# Check node count
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 4)
forest.refine(subforest_flag=1)
# Check node count
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 10)
forest.coarsen(subforest_flag=1)
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 4)
# Now try with a refinement flag
forest.get_child(1).mark(2)
forest.refine(subforest_flag=1, refinement_flag=2)
# Check node count
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 6)
# =====================================================================
# Refine with new label
# =====================================================================
forest = Forest([Tree(2), Tree(2)])
forest.refine()
# Define subforest
forest.get_child(0).get_child(0).mark(1)
forest.root_subtrees(1)
# Check node count
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 4)
forest.refine(subforest_flag=1, new_label=4)
# Node count of new label
count = 0
for dummy in forest.traverse(4):
count += 1
self.assertEqual(count, 10)
# Node count for original submesh
count = 0
for dummy in forest.traverse(1):
count += 1
self.assertEqual(count, 4)
# Refinement marker
forest.get_child(1).mark(3)
# Refine
forest.refine(subforest_flag=1, refinement_flag=3, new_label=5)
# Check node count
count = 0
for dummy in forest.traverse(5):
count += 1
self.assertEqual(count, 6)
def test_coarsen(self):
# =====================================================================
# Simple Coarsening
# =====================================================================
# Define a new forest with two quadtrees
forest = Forest([Tree(4), Tree(4)])
# Coarsen, nothing should happen
forest.coarsen()
# Check that forest is as it was
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 2)
# Refine and coarsen again
forest.refine()
forest.coarsen()
# Check that forest is as it was
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 2)
# =====================================================================
# Coarsening Flag
# =====================================================================
# Refine and mark one grandchild
forest.refine()
# Check that forest now has 10 Tree
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 10)
forest.get_child(0).mark(1)
forest.coarsen(coarsening_flag=1)
# Tree 0 should not have children, while Tree 1 should have 4
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
self.assertFalse(forest.get_child(0).has_children())
self.assertTrue(forest.get_child(1).has_children())
# Nothing is marked 1
self.assertFalse(any(
child.is_marked(1) for child in forest.traverse()))
# =====================================================================
# Coarsening with subforests
# =====================================================================
forest = Forest([Tree(2), Tree(2)])
forest.refine()
# Make a subforest 0, 00, 01, 1
forest.get_child(0).get_child(0).mark(2)
forest.root_subtrees(2)
count = 0
for node in forest.traverse(flag=2):
count += 1
self.assertEqual(count, 4)
# Coarsen the subforest
forest.coarsen(subforest_flag=2)
# Subforest now contains [0], [1]
count = 0
for dummy in forest.traverse(flag=2):
count += 1
self.assertEqual(count, 2)
# Forest still contains 4 nodes (0,1,00,01,10,11)
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
# New subforest: 0, 00, 01, 1
forest.get_child(0).get_child(0).mark(2)
forest.root_subtrees(2)
# Count subforest nodes
count = 0
for dummy in forest.traverse(2):
count += 1
self.assertEqual(count, 4)
# Coarsening flag at a node not in the subforest
forest.get_child(1).get_child(1).mark(1)
forest.coarsen(subforest_flag=2, coarsening_flag=1)
# Count subforest nodes
count = 0
for dummy in forest.traverse(2):
count += 1
self.assertEqual(count, 4)
# Apply coarsening flag to a node in the subforest
forest.get_child(0).mark(1)
# Coarsen
forest.coarsen(subforest_flag=2, coarsening_flag=1)
# Now there should be 2 subnodes
count = 0
for dummy in forest.traverse(2):
count += 1
self.assertEqual(count, 2)
# Make sure the coarsening flag is deleted.
self.assertFalse(forest.get_child(0).is_marked(1))
# =====================================================================
# Coarsening with new_label
# =====================================================================
# TODO: TEST HERE.
# Subforest is: 0, 00, 01, 1
forest.get_child(0).get_child(0).mark(2)
forest.root_subtrees(2)
# Mark [0,0] with coarsening flag
forest.get_child(0).mark(1)
# Coarsen subforest and label with new_label
forest.coarsen(subforest_flag=2,
coarsening_flag=1,
new_label=3,
debug=True)
# Check that subforest still has the same nodes
count = 0
for dummy in forest.traverse(2):
count += 1
self.assertEqual(count, 4)
# Check that the new submesh has fewer
count = 0
for dummy in forest.traverse(3):
count += 1
self.assertEqual(count, 2)
#
# Now with no submesh
#
# Check that forest still has 6 nodes
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
# Mark with coarsening flag
forest.get_child(0).mark(1)
# Coarsen
forest.coarsen(coarsening_flag=1, new_label=4)
# Check that forest still has 6 nodes
count = 0
for dummy in forest.traverse():
count += 1
self.assertEqual(count, 6)
# Check that subforest has 5 nodes
count = 0
for dummy in forest.traverse(4):
count += 1
self.assertEqual(count, 4)
def test_child(self):
forest = Forest()
self.assertRaises(Exception, forest.get_child, *(0, ))
forest = Forest([Tree(1), Tree(4)])
self.assertEqual(forest.get_child(1).n_children(), 4)