Add tests for coverage and fix bugs

Author: FranzBangar

examples/shape/cylinder.py

@@ -1,40 +1,32 @@
 import os
 
 import classy_blocks as cb
-from classy_blocks.construct.flat.sketches.disk import DiskBase
-
-DiskBase.core_ratio = 0.4  # Default is 0.8
 
 mesh = cb.Mesh()
 
 axis_point_1 = [0.0, 0.0, 0.0]
 axis_point_2 = [5.0, 5.0, 0.0]
 radius_point_1 = [0.0, 0.0, 2.0]
 
-cylinder = cb.QuarterCylinder(axis_point_1, axis_point_2, radius_point_1)
+cylinder = cb.Cylinder(axis_point_1, axis_point_2, radius_point_1)
 
 cylinder.set_start_patch("inlet")
 cylinder.set_end_patch("outlet")
 cylinder.set_outer_patch("walls")
-cylinder.set_symmetry_patch("sym")
 
-# if curved core edges get in the way (when moving vertices, optimization, ...),
+# If curved core edges get in the way (when moving vertices, optimization, ...),
 # remove them with this method:
 cylinder.remove_inner_edges(start=False, end=True)
 
+# Chop and grade
 bl_thickness = 1e-3
 core_size = 0.1
 
-# manual grading
-# cylinder.chop_axial(count=30)
-# cylinder.chop_radial(start_size=core_size, end_size=bl_thickness)
-# cylinder.chop_tangential(start_size=core_size)
+cylinder.chop_axial(count=30)
+cylinder.chop_radial(start_size=core_size, end_size=bl_thickness)
+cylinder.chop_tangential(start_size=core_size)
 
 mesh.add(cylinder)
 mesh.modify_patch("walls", "wall")
 
-# automatic grading
-grader = cb.SmoothGrader(mesh, 0.1)
-grader.grade()
-
 mesh.write(os.path.join("..", "case", "system", "blockMeshDict"), debug_path="debug.vtk")

examples/shape/one_core_cylinder.py

@@ -0,0 +1,27 @@
+import os
+
+import classy_blocks as cb
+from classy_blocks.construct.flat.sketches.disk import OneCoreDisk
+from classy_blocks.util import functions as f
+
+# A simpler version of a Cylinder with only a single block in the middle;
+# easier to block but slightly worse cell quality;
+# currently there is no OneCoreCylinder shape so it has to be extruded;
+# two lines are needed instead of one.
+
+mesh = cb.Mesh()
+
+axis_point_1 = f.vector(0.0, 0.0, 0.0)
+axis_point_2 = f.vector(5.0, 5.0, 0.0)
+radius_point_1 = f.vector(0.0, 0.0, 2.0)
+
+
+one_core_disk = OneCoreDisk(axis_point_1, radius_point_1, axis_point_1 - axis_point_2)
+quarter_cylinder = cb.ExtrudedShape(one_core_disk, f.norm(axis_point_2 - axis_point_1))
+quarter_cylinder.chop(0, count=5)
+quarter_cylinder.chop(1, count=10)
+quarter_cylinder.chop(2, count=20)
+mesh.add(quarter_cylinder)
+
+mesh.set_default_patch("walls", "wall")
+mesh.write(os.path.join("..", "case", "system", "blockMeshDict"), debug_path="debug.vtk")

examples/shape/quarter_cylinder.py

@@ -18,8 +18,8 @@
 
 mesh.add(quarter_cylinder)
 
-mesh.assemble()
-
+# Use an automatic grader that will try to make cells in neighbouring blocks
+# as similar in size as possible
 grader = cb.SmoothGrader(mesh, 0.05)
 grader.grade()
 

src/classy_blocks/construct/flat/sketches/disk.py

@@ -191,9 +191,8 @@ def parts(self):
 
 class OneCoreDisk(DiskBase):
     """A disk with a single block in  the center and four blocks around;
-    see docs/blocking for point numbers and faces/grid indexing."""
+    see docs/sketches for point numbers and faces/grid indexing."""
 
-    # TODO: test
     chops: ClassVar = [
         [1],  # axis 0
         [1, 2],  # axis 1
@@ -220,6 +219,10 @@ def __init__(self, center_point: PointType, radius_point: PointType, normal: Vec
     def center(self):
         return self.faces[0].center
 
+    @property
+    def origo(self):
+        return self.faces[0].center
+
     @property
     def grid(self):
         return [self.faces[:1], self.faces[1:]]
@@ -229,7 +232,7 @@ def add_core_spline_edges(self):
 
 
 class QuarterDisk(DiskBase):
-    """A quarter of a four-core disk; see docs/blocking for point numbers and faces/grid indexing"""
+    """A quarter of a four-core disk; see docs/sketches for point numbers and faces/grid indexing"""
 
     chops: ClassVar = [
         [1],  # axis 0

src/classy_blocks/construct/shapes/cylinder.py

@@ -116,3 +116,6 @@ def fill(cls, source: "ExtrudedRing") -> "Cylinder":
             )
 
         return cls(source.sketch_1.center, source.sketch_2.center, source.sketch_1.inner_radius_point)
+
+    def set_symmetry_patch(self, _name: str) -> None:
+        raise RuntimeError("Cylinder does not have symmetry patches")

src/classy_blocks/grading/autograding/fixed/rules.py

@@ -15,5 +15,7 @@ def get_count(self, _length, _start_at_wall, _end_at_wall):
     def is_squeezed(self, _count, _info) -> bool:
         return True  # grade everything in first pass
 
-    def get_chops(self, count, _info) -> List[Chop]:
-        return [Chop(count=count)]
+    def get_chops(self, _count, _info) -> List[Chop]:
+        # In FixedCountGrader this is never called
+        # (everything is graded as 'squeezed')
+        raise RuntimeError

src/classy_blocks/grading/autograding/grader.py

@@ -1,4 +1,3 @@
-import abc
 from typing import List, Tuple, get_args
 
 from classy_blocks.cbtyping import ChopTakeType, DirectionType
@@ -10,9 +9,7 @@
 from classy_blocks.mesh import Mesh
 
 
-class GraderBase(abc.ABC):
-    stages: int
-
+class GraderBase:
     def __init__(self, mesh: Mesh, rules: ChopRules):
         self.mesh = mesh
         self.rules = rules
@@ -57,11 +54,6 @@ def set_counts(self, row: Row, take: ChopTakeType) -> None:
 
     def grade_squeezed(self, row: Row) -> None:
         for entry in row.entries:
-            # TODO! don't touch wires, defined by USER
-            # if wire.is_defined:
-            #    # TODO: test
-            #    continue
-
             for wire in entry.wires:
                 if wire.is_defined:
                     continue
@@ -74,10 +66,6 @@ def grade_squeezed(self, row: Row) -> None:
 
     def finalize(self, row: Row) -> None:
         for entry in row.entries:
-            # TODO! don't touch wires, defined by USER
-            # if wire.is_defined:
-            #    # TODO: test
-            #    continue
             for wire in entry.wires:
                 if wire.is_defined:
                     continue

tests/test_construct/test_flat/test_disk.py

@@ -5,7 +5,9 @@
 from parameterized import parameterized
 
 from classy_blocks.construct.flat.sketches.disk import HalfDisk, OneCoreDisk, Oval, QuarterDisk, WrappedDisk
+from classy_blocks.construct.shape import ExtrudedShape
 from classy_blocks.construct.shapes.sphere import get_named_points
+from classy_blocks.mesh import Mesh
 from classy_blocks.util import functions as f
 from classy_blocks.util.constants import TOL
 
@@ -107,6 +109,11 @@ def test_one_core_disk(self):
         self.assertEqual(len(disk.grid[0]), 1)
         self.assertEqual(len(disk.grid[1]), 4)
 
+    def test_one_core_disk_origo(self):
+        disk = OneCoreDisk([0, 0, 0], [1, 0, 0], [0, 0, 1])
+
+        np.testing.assert_array_almost_equal(disk.origo, [0, 0, 0])
+
     def test_half_disk(self):
         disk = HalfDisk([0, 0, 0], [1, 0, 0], [0, 0, 1])
 
@@ -148,3 +155,19 @@ def test_grid(self):
 
         self.assertEqual(len(oval.grid[0]), 6)
         self.assertEqual(len(oval.grid[1]), 10)
+
+
+class ChopTests(unittest.TestCase):
+    def setUp(self):
+        self.mesh = Mesh()
+
+    def test_one_core_disk(self):
+        sketch = OneCoreDisk([0, 0, 0], [1, 0, 0], [0, 0, 1])
+        extrude = ExtrudedShape(sketch, 1)
+
+        extrude.chop(0, count=10)
+        extrude.chop(1, count=5)
+        extrude.chop(2, count=1)
+
+        self.mesh.add(extrude)
+        self.mesh.assemble()

tests/test_construct/test_shape.py

@@ -322,6 +322,10 @@ def test_remove_inner_edges(self):
             for edge in operation.top_face.edges:
                 self.assertIsInstance(edge, Line)
 
+    def test_symmetry_patches(self):
+        with self.assertRaises(RuntimeError):
+            self.cylinder.set_symmetry_patch("test")
+
 
 class LoftedShapeTests(unittest.TestCase):
     @property

tests/test_grading/test_autograde.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 
+import classy_blocks as cb
 from classy_blocks.construct.flat.sketches.grid import Grid
 from classy_blocks.construct.operations.box import Box
 from classy_blocks.construct.shapes.cylinder import Cylinder
@@ -65,7 +66,7 @@ def test_simple_grader_stack(self):
             for axis in block.axes:
                 self.assertEqual(axis.count, 5)
 
-    def test_highre_cylinder(self):
+    def test_smooth_cylinder(self):
         self.mesh.add(self.get_cylinder())
         self.mesh.assemble()
 
@@ -75,3 +76,37 @@ def test_highre_cylinder(self):
         # make sure all blocks are defined
         for block in self.mesh.blocks:
             self.assertTrue(block.is_defined)
+
+
+class AdvancedAutogradeTests(unittest.TestCase):
+    def setUp(self):
+        self.mesh = Mesh()
+
+    def get_grid(self, badness: float = 0.8):
+        # 6 blocks of weird shape, taken from the autograder examples
+        # but with adjustable 'badness' (amount of displacement)
+        # to test border cases
+        base = cb.Grid([0, 0, 0], [3, 2, 0], 3, 2)
+        shape = cb.ExtrudedShape(base, 1)
+
+        # turn one block around
+        shape.grid[1][0].rotate(np.pi, [0, 0, 1])
+        self.mesh.add(shape)
+
+        # move some points to get a mesh with uneven blocks
+        self.mesh.assemble()
+        finder = cb.GeometricFinder(self.mesh)
+
+        move_points = [[0, 1, 1], [2, 1, 1], [3, 1, 1]]
+
+        for point in move_points:
+            vertex = next(iter(finder.find_in_sphere(point)))
+            vertex.translate([0, badness, 0])
+
+    def test_squeezed_chop(self):
+        self.get_grid()
+
+        grader = SmoothGrader(self.mesh, 0.05)
+        grader.grade()
+
+        self.assertIsNone(self.mesh.blocks[5].axes[1].wires[1].grading.chops[0].total_expansion)