Add sequential neighbours (before/after)

Author: FranzBangar

src/classy_blocks/items/block.py

@@ -93,6 +93,7 @@ def add_neighbour(self, candidate: "Block") -> None:
         for this_axis in self.axes:
             for cnd_axis in candidate.axes:
                 this_axis.add_neighbour(cnd_axis)
+                this_axis.add_sequential(cnd_axis)
 
         # wires
         for this_wire in self.wire_list:

src/classy_blocks/items/wires/axis.py

@@ -1,6 +1,7 @@
 from typing import List, Set
 
 from classy_blocks.grading.chop import Chop
+from classy_blocks.items.vertex import Vertex
 from classy_blocks.items.wires.manager import WireChopManager, WireManagerBase, WirePropagateManager
 from classy_blocks.items.wires.wire import Wire
 from classy_blocks.types import AxisType
@@ -40,7 +41,7 @@ def __init__(self, index: AxisType, wires: List[Wire]):
         # will be replaced by a ChopManager
         self.wires: WireManagerBase = WirePropagateManager(wires)
 
-        # will be added as blocks are added to mesh
+        # will be added after blocks are added to mesh
         self.neighbours: Set[Axis] = set()
 
     def add_neighbour(self, axis: "Axis") -> None:
@@ -50,6 +51,14 @@ def add_neighbour(self, axis: "Axis") -> None:
                 if this_wire.is_coincident(nei_wire):
                     self.neighbours.add(axis)
 
+    def add_sequential(self, axis: "Axis") -> None:
+        """Adds an axis that comes before/after this one"""
+        # As opposed to neighbours that are 'around' this axis
+        if self.start_vertices == axis.end_vertices or self.end_vertices == axis.start_vertices:
+            for this_wire in self.wires:
+                for nei_wire in axis.wires:
+                    this_wire.add_series(nei_wire)
+
     def is_aligned(self, other: "Axis") -> bool:
         """Returns True if wires of the other axis are aligned
         to wires of this one"""
@@ -95,6 +104,14 @@ def copy_grading(self) -> bool:
 
         return False
 
+    @property
+    def start_vertices(self) -> Set[Vertex]:
+        return {wire.vertices[0] for wire in self.wires}
+
+    @property
+    def end_vertices(self) -> Set[Vertex]:
+        return {wire.vertices[1] for wire in self.wires}
+
     def grade(self) -> None:
         self.wires.grade()
 

src/classy_blocks/items/wires/wire.py

@@ -26,8 +26,12 @@ def __init__(self, vertices: List[Vertex], axis: int, corner_1: int, corner_2: i
         self.grading = Grading(self.length)
 
         # multiple wires can be at the same spot; this list holds other
-        # coincident wires
+        # coincident wires from different blocks
         self.coincidents: Set[Wire] = set()
+        # wires that precede this (end with this wire's beginning vertex)
+        self.before: Set[Wire] = set()
+        # wires that follow this (start with this wire's end vertex)
+        self.after: Set[Wire] = set()
 
     @property
     def length(self) -> float:
@@ -56,6 +60,13 @@ def add_coincident(self, wire):
         if self.is_coincident(wire):
             self.coincidents.add(wire)
 
+    def add_series(self, wire):
+        """Adds a reference to a wire that is before or after this one"""
+        if wire.vertices[1] == self.vertices[0]:
+            self.before.add(wire)
+        elif wire.vertices[0] == self.vertices[1]:
+            self.after.add(wire)
+
     def add_chop(self, chop: Chop) -> None:
         """Adds Chops to this Wire's Grading object"""
         self.grading.add_chop(chop)

src/classy_blocks/lists/block_list.py

@@ -18,10 +18,6 @@ def add(self, block: Block) -> None:
         self.blocks.append(block)
         self.update_neighbours(block)
 
-    def grade_blocks(self) -> None:
-        for block in self.blocks:
-            block.grade()
-
     def update_neighbours(self, new_block: Block) -> None:
         """Find and assign neighbours of a given block entry"""
         for block in self.blocks:
@@ -31,6 +27,10 @@ def update_neighbours(self, new_block: Block) -> None:
             block.add_neighbour(new_block)
             new_block.add_neighbour(block)
 
+    def grade_blocks(self) -> None:
+        for block in self.blocks:
+            block.grade()
+
     def propagate_gradings(self):
         """Copy references to gradings from defined blocks to their neighbours"""
         # a riddle similar to sudoku, keep traversing
@@ -70,6 +70,16 @@ def check_consistency(self):
         for block in self.blocks:
             block.check_consistency()
 
+    def assemble(self) -> None:
+        # 1. set counts on user-defined axes
+        self.grade_blocks()
+        # 2. distribute counts over all blocks
+        self.propagate_gradings()
+        # 3. set gradings on missing wires
+
+        # 4. check that everything is in order
+        self.check_consistency()
+
     def clear(self) -> None:
         """Removes created blocks"""
         self.blocks.clear()

src/classy_blocks/mesh.py

@@ -132,14 +132,6 @@ def assemble(self, skip_edges: bool = False) -> None:
             if entity.geometry is not None:
                 self.add_geometry(entity.geometry)
 
-    def grade(self) -> None:
-        if not self.is_assembled:
-            raise RuntimeError("Cannot grade a mesh before it is assembled")
-
-        self.block_list.grade_blocks()
-        self.block_list.propagate_gradings()
-        self.block_list.check_consistency()
-
     def clear(self) -> None:
         """Undoes the assemble() method; clears created blocks and other lists
         but leaves added depot items intact"""
@@ -197,7 +189,7 @@ def write(self, output_path: str, debug_path: Optional[str] = None) -> None:
 
         # gradings: define after writing VTK;
         # if it is not specified correctly, this will raise an exception
-        self.grade()
+        self.block_list.assemble()
 
         with open(output_path, "w", encoding="utf-8") as output:
             output.write(constants.MESH_HEADER)

tests/test_construct/test_edge_grading.py

@@ -43,7 +43,7 @@ def setUp(self):
         mesh.add(end)
 
         mesh.assemble()
-        mesh.grade()
+        mesh.block_list.assemble()
 
         self.mesh = mesh
 
@@ -78,7 +78,7 @@ def setUp(self):
 
     def prepare(self):
         self.mesh.assemble()
-        self.mesh.grade()
+        self.mesh.block_list.assemble()
 
     def test_inconsistent_wires(self):
         box_left = Box([0, 0, 0], [1, 1, 1])

tests/test_items/test_axis.py

@@ -48,3 +48,14 @@ def test_is_not_aligned(self):
         block_0.add_neighbour(block_1)
 
         self.assertFalse(block_1.axes[1].is_aligned(block_0.axes[1]))
+
+    @parameterized.expand(((0,), (1,), (2,), (3,)))
+    def test_sequential(self, corner):
+        block_1 = self.make_block(1)
+        block_2 = self.make_block(2)
+
+        block_1.add_neighbour(block_2)
+        block_2.add_neighbour(block_1)
+
+        self.assertListEqual(list(block_1.axes[1].wires[corner].after), [block_2.axes[1].wires[corner]])
+        self.assertListEqual(list(block_2.axes[1].wires[corner].before), [block_1.axes[1].wires[corner]])

tests/test_mesh.py

@@ -171,7 +171,7 @@ def test_chop_shape_axial(self):
 
         self.mesh.add(cyl)
         self.mesh.assemble()
-        self.mesh.grade()
+        self.mesh.block_list.assemble()
 
         for block in self.mesh.block_list.blocks:
             self.assertEqual(block.axes[2].count, 10)
@@ -185,7 +185,7 @@ def test_chop_cylinder_tangential(self):
 
         self.mesh.add(cyl)
         self.mesh.assemble()
-        self.mesh.grade()
+        self.mesh.block_list.assemble()
 
         for block in self.mesh.block_list.blocks:
             self.assertEqual(block.axes[1].count, 10)

tests/test_propagation.py

@@ -22,7 +22,7 @@ def test_propagate_normal(self):
         self.mesh.add(op_1)
 
         self.mesh.assemble()
-        self.mesh.grade()
+        self.mesh.block_list.assemble()
 
         self.assertListEqual(
             self.mesh.block_list.blocks[0].axes[1].wires[2].grading.specification,
@@ -43,7 +43,7 @@ def test_propagate_upsidedown(self):
         self.mesh.add(op_1)
 
         self.mesh.assemble()
-        self.mesh.grade()
+        self.mesh.block_list.assemble()
 
         self.assertListEqual(
             self.mesh.block_list.blocks[0].axes[1].wires[3].grading.specification,