Fix GradingManager (missing axes for propagation), add tests

Author: FranzBangar

examples/complex/cyclone/cyclone.py

@@ -80,7 +80,7 @@ def add_regions(regions: list[Region]) -> None:
     for clamp in region.get_clamps(mesh):
         optimizer.add_clamp(clamp)
 
-optimizer.optimize(tolerance=1e-3, max_iterations=20)
+# optimizer.optimize(tolerance=1e-3, max_iterations=20)
 
 # Now Block objects contain optimization results but those are not reflected in
 # user-created Operations. Mesh.backport() will copy the data back.

src/classy_blocks/grading/define/chop.py

@@ -85,26 +85,28 @@ def defined_params(self) -> int:
         grading_params = [self.start_size, self.end_size, self.count, self.total_expansion, self.c2c_expansion]
         return len(grading_params) - grading_params.count(None)
 
+    def __post_init__(self):
+        self.check()
+
     def check(self):
         # check that the user did not overdefine the chop;
         # if more than 2 parameters are given, the results might change between runs because
         # of the iterative calculation
         if self.defined_params > 2:
-            # TODO: test
             raise ValueError("Over-defined Chop; speficy at most 2 grading parameters!")
 
-        # default: take c2c_expansion=1 if there's less than 2 parameters given
-        if self.defined_params < 2:
-            if self.c2c_expansion is None:
-                self.c2c_expansion = 1
-
         # also: count can only be an integer
         if self.count is not None:
             self.count = max(int(self.count), 1)
 
     def calculate(self, length: float) -> ChopData:
         self.check()
 
+        # default: take c2c_expansion=1 if there's less than 2 parameters given
+        if self.defined_params < 2:
+            if self.c2c_expansion is None:
+                self.c2c_expansion = 1
+
         """Calculates cell count and total expansion ratio for this chop
         by calling functions that take known variables and return new values"""
         data = dataclasses.asdict(self)

src/classy_blocks/grading/define/collector.py

@@ -33,8 +33,5 @@ def clear(self) -> None:
     def is_edge_chopped(self) -> bool:
         return self._edge_chops_count > 0
 
-    def __len__(self):
-        return len(self.axis_chops)
-
     def __getitem__(self, i: DirectionType):
         return self.axis_chops[i]

src/classy_blocks/grading/graders/manager.py

@@ -22,7 +22,8 @@ def __init__(self, wire: Wire):
     def copy(from_wire: Wire, to_wire: Wire) -> None:
         """Copies grading from another wire but takes care to orient it properly"""
         if to_wire.grading.is_defined:
-            raise InconsistentGradingsError(f"Copying grading to a defined wire! (From {from_wire} to {to_wire})")
+            if to_wire.grading != from_wire.grading:
+                raise InconsistentGradingsError(f"Copying grading to a defined wire! (From {from_wire} to {to_wire})")
 
         to_wire.grading = from_wire.grading.copy(to_wire.length, not to_wire.is_aligned(from_wire))
 
@@ -140,7 +141,6 @@ def grade(self) -> int:
             grader = WireGrader(wire)
             # TODO: assign priority to Chop so it's possible
             # to tell whether to copy the grading to coincidents or take an existing one from them
-            # TODO: put this grading-copy-logic into the WireGrader, duh?
             grader.assign(grading.copy(wire.length, False))
 
         return grading.count
@@ -152,11 +152,19 @@ def __init__(self, row: Row):
         self.axes = set(row.get_axes())
 
         # each wire belongs to an axis; create a lookup dict
-        self.wire_to_axis: dict[Wire, Axis] = {}
+        self.wire_to_axis: dict[Wire, set[Axis]] = {}
 
         for axis in self.axes:
             for wire in axis.wires:
-                self.wire_to_axis[wire] = axis
+                if wire not in self.wire_to_axis:
+                    self.wire_to_axis[wire] = set()
+
+                self.wire_to_axis[wire].add(axis)
+                for coincident in wire.coincidents:
+                    if coincident not in self.wire_to_axis:
+                        self.wire_to_axis[coincident] = set()
+
+                    self.wire_to_axis[coincident].add(axis)
 
         self.defined: set[Axis] = set(axis for axis in self.axes if axis.is_graded)
 
@@ -206,7 +214,7 @@ def _propagate_wires(self, axis: Axis) -> set[Axis]:
             wire_grader = WireGrader(wire)
             wire_grader.copy_to_coincidents()
             for coincident in wire.coincidents:
-                fresh_neighbours.add(self.wire_to_axis[coincident])
+                fresh_neighbours.update(self.wire_to_axis[coincident])
 
         return fresh_neighbours
 

src/classy_blocks/items/wires/wire.py

@@ -103,5 +103,5 @@ def is_graded(self) -> bool:
     def __repr__(self):
         return f"Wire {self.corners[0]}-{self.corners[1]} ({self.vertices[0].index}-{self.vertices[1].index})"
 
-    def __hash__(self):
-        return self.key
+    # def __hash__(self):
+    #     return self.key

src/classy_blocks/lists/block_list.py

@@ -3,8 +3,7 @@
 
 
 class BlockList:
-    """Handling of the 'blocks' part of blockMeshDict, along with
-    count/grading propagation and whatnot"""
+    """Handling of the 'blocks' part of blockMeshDict"""
 
     def __init__(self) -> None:
         self.blocks: list[Block] = []
@@ -13,22 +12,13 @@ def add(self, block: Block) -> None:
         """Add blocks"""
         self.blocks.append(block)
 
-    def update_neighbours(self, navigator: HexPointRegistry) -> None:
+    def update_neighbours(self, registry: HexPointRegistry) -> None:
         """Find and assign neighbours of a given block entry"""
         for block in self.blocks:
-            neighbour_indexes = navigator.find_cell_neighbours(block.index)
+            neighbour_indexes = registry.find_cell_neighbours(block.index)
 
             for i in neighbour_indexes:
                 block.add_neighbour(self.blocks[i])
 
-    def update_lengths(self) -> None:
-        """Update lengths on grading objects"""
-        # Grading on each wire was specified with length 0;
-        # after edges have been added to blocks, they now have a proper
-        # value to work with
-        for block in self.blocks:
-            for wire in block.wire_list:
-                wire.update()
-
     def __hash__(self):
         return id(self)

src/classy_blocks/mesh.py

@@ -114,6 +114,8 @@ def grade(self) -> None:
         Will fail if the mesh has not been assembled yet and will also raise an
         exception if chops are over- or under-defined.
         Is called automatically when writing the mesh."""
+        self.assemble()
+
         assert isinstance(self.dump, AssembledDump)  # to pacify type checker
 
         manager = GradingManager(self.dump, self.settings)

src/classy_blocks/write/writer.py

@@ -58,7 +58,6 @@ def format_settings(settings: Settings):
 
     for key, value in asdict(settings).items():
         if key in ("patch_settings", "merged_patches", "default_patch", "geometry"):
-            # FIXME: this is a temporary fix, Writer will handle that anyway
             continue
 
         key_words = key.split("_")
@@ -86,7 +85,7 @@ def write(self, output_path: str):
             output.write(format_list("vertices", self.dump.vertices, format_vertex))
             output.write(format_list("blocks", self.dump.blocks, format_block))
             output.write(format_list("edges", self.dump.edges, format_edge))
-            output.write(format_list("boundary", list(self.dump.patch_list.patches.values()), format_patch))
+            output.write(format_list("boundary", list(self.dump.patches), format_patch))
             output.write(format_list("faces", self.dump.face_list.faces, format_face))
 
             output.write(format_settings(self.settings))

tests/test_grading/test_collector.py

@@ -0,0 +1,42 @@
+import unittest
+
+from classy_blocks.grading.define.collector import Chop, ChopCollector
+
+
+class CollectorTests(unittest.TestCase):
+    def test_chop_edge_single(self):
+        c = ChopCollector()
+
+        c.chop_edge(0, 1, Chop(count=10))
+
+        edge_chops = 0
+        for beam in c.edge_chops.get_all_beams():
+            if beam:
+                edge_chops += 1
+        self.assertEqual(edge_chops, 1)
+
+    def test_chop_edge_multiple(self):
+        c = ChopCollector()
+
+        c.chop_edge(0, 1, Chop(count=10))
+        c.chop_edge(3, 2, Chop(count=10))
+
+        edge_chops = 0
+        for beam in c.edge_chops.get_all_beams():
+            if beam:
+                edge_chops += 1
+        self.assertEqual(edge_chops, 2)
+
+    def test_is_not_edge_chopped(self):
+        c = ChopCollector()
+
+        c.chop_axis(0, Chop(count=10))
+
+        self.assertFalse(c.is_edge_chopped)
+
+    def test_is_edge_chopped(self):
+        c = ChopCollector()
+
+        c.chop_edge(0, 1, Chop(count=10))
+
+        self.assertTrue(c.is_edge_chopped)

tests/test_construct/test_edge_grading.py tests/test_grading/test_edge_grading.pytests/test_construct/test_edge_grading.py renamed to tests/test_grading/test_edge_grading.py

@@ -3,8 +3,8 @@
 
 import numpy as np
 
-from classy_blocks.base.exceptions import InconsistentGradingsError
-from classy_blocks.cbtyping import DirectionType
+from classy_blocks.base.exceptions import InconsistentGradingsError, UndefinedGradingsError
+from classy_blocks.cbtyping import DirectionType, GradingSpecType
 from classy_blocks.construct.edges import Arc
 from classy_blocks.construct.operations.box import Box
 from classy_blocks.construct.operations.connector import Connector
@@ -150,3 +150,70 @@ def test_propagated_count(self):
 
         for block in self.mesh.blocks:
             self.assertTrue(" ( 10 10 10 ) simpleGrading" in formats.format_block(block))
+
+
+class BoxEdgeChopTests(unittest.TestCase):
+    """Edge chopping on a single operation"""
+
+    def setUp(self):
+        self.box = Box([0, 0, 0], [1, 1, 1])
+        self.mesh = Mesh()
+
+        self.mesh.add(self.box)
+
+    def finalize(self):
+        self.mesh.assemble()
+        self.mesh.grade()
+
+    def get_grading(self, direction: DirectionType, i_wire: int) -> list[GradingSpecType]:
+        self.finalize()
+
+        return self.mesh.blocks[0].axes[direction].wires[i_wire].grading.specification
+
+    def test_edge_chop_solo_fail(self):
+        """Cannot use edge chopping if the mesh is not fully defined"""
+        self.box.chop_edge(0, 1, count=30)
+
+        with self.assertRaises(UndefinedGradingsError):
+            self.finalize()
+
+    def test_edge_chop_solo_success(self):
+        for i in get_args(DirectionType):
+            self.box.chop(i, count=(i + 1) * 5)
+
+        self.box.chop_edge(0, 1, start_size=0.05)
+
+        self.finalize()
+
+        # one edge is graded, the rest are simple
+        self.assertAlmostEqual(self.get_grading(0, 0)[0][2], 9.043586, places=5)
+        self.assertAlmostEqual(self.get_grading(0, 1)[0][2], 1)
+
+    def test_edge_chop_multiple(self):
+        """Do multiple chops and let the last chop define the remaining count automatically"""
+
+        self.box.chop(0, count=20)
+        self.box.chop(1, count=10)
+        self.box.chop(2, count=10)
+
+        self.box.chop_edge(0, 1, length_ratio=0.49, start_size=0.1)  # 5 cells
+        self.box.chop_edge(0, 1, length_ratio=0.51, end_size=0.05)  # the rest
+
+        self.finalize()
+
+        self.assertEqual(self.get_grading(0, 0)[0][1], 5)
+        self.assertEqual(self.get_grading(0, 0)[1][1], 15)
+
+    def test_clear(self):
+        for i in get_args(DirectionType):
+            self.box.chop(i, count=(i + 1) * 5)
+        self.box.chop_edge(0, 1, start_size=0.5)
+        self.box.chop_edge(1, 2, count=30)
+
+        self.box.chops.clear()
+
+        self.assertListEqual(self.box.chops.axis_chops[0], [])
+        self.assertListEqual(self.box.chops.axis_chops[1], [])
+        self.assertListEqual(self.box.chops.axis_chops[2], [])
+
+        self.assertFalse(self.box.chops.is_edge_chopped)