Add tests, resolve issues

Author: FranzBangar

examples/advanced/edge_grading.py

@@ -1,7 +1,5 @@
 import os
 
-import numpy as np
-
 import classy_blocks as cb
 
 mesh = cb.Mesh()
@@ -24,11 +22,8 @@
 contract.chop(2, start_size=0.1)
 mesh.add(contract)
 
-# rotate the end block to demonstrate grading propagation on non-aligned blocks
 end = cb.Extrude(contract.get_face("top"), 1)
-end.rotate(np.pi, [0, 0, 1])
 end.chop(2, start_size=0.1)
-
 mesh.add(end)
 
 mesh.set_default_patch("walls", "wall")

src/classy_blocks/construct/operations/operation.py

@@ -64,7 +64,21 @@ def chop(self, axis: AxisType, **kwargs: Unpack[ChopArgs]) -> None:
         1: along second edge of a face
         2: between faces / along operation path
 
-        Kwargs: see arguments for Chop object"""
+        kwargs:
+        Available grading parameters are:
+         - start_size: width of start cell
+         - end_size: width of end cell
+         - count: cell count in given direction
+         - c2c_expansion: cell-to-cell expansion ratio (default=1)
+         - total_expansion: ratio between first and last cell size
+
+        You must specify start_size and/or count.
+        c2c_expansion is optional - will be used to create graded cells
+        and will default to 1 if not provided.
+
+        Use length_ratio for multigrading (see documentation):
+        https://cfd.direct/openfoam/user-guide/v9-blockMesh/#multi-grading"""
+
         self.chops[axis].append(Chop(**kwargs))
 
     def unchop(self, axis: AxisType) -> None:

src/classy_blocks/grading/chop.py

@@ -131,8 +131,8 @@ def copy_preserving(self, inverted: bool = False) -> "Chop":
             args[arg] = None
 
         args[self.preserve] = self.results[self.preserve]
-        chop = Chop(**args)
 
+        chop = Chop(**args)
         if inverted:
             chop.invert()
 

src/classy_blocks/grading/grading.py

@@ -54,23 +54,6 @@ def __init__(self, length: float):
         self.specification: List[List] = []  # a list of lists [length ratio, count ratio, total expansion]
 
     def add_chop(self, chop: Chop) -> None:
-        """Add a grading division to block specification.
-        Use length_ratio for multigrading (see documentation).
-        Available grading parameters are:
-         - start_size: width of start cell
-         - end_size: width of end cell
-         - count: cell count in given direction
-         - c2c_expansion: cell-to-cell expansion ratio (default=1)
-         - total_expansion: ratio between first and last cell size
-
-        You must specify start_size and/or count.
-        c2c_expansion is optional - will be used to create graded cells
-        and will default to 1 if not provided.
-
-        To reverse grading, use invert=True.
-
-        Documentation:
-        https://cfd.direct/openfoam/user-guide/v9-blockMesh/#multi-grading"""
         if not (0 < chop.length_ratio <= 1):
             raise ValueError(f"Length ratio must be between 0 and (including) 1, got {chop.length_ratio}")
 
@@ -160,3 +143,6 @@ def __eq__(self, other):
                     return False
 
         return True
+
+    def __repr__(self) -> str:
+        return str(self.specification)

src/classy_blocks/items/block.py

@@ -121,6 +121,10 @@ def is_defined(self) -> bool:
         """Returns True if counts and gradings are defined for all axes"""
         return all(axis.is_defined for axis in self.axes)
 
+    def grade(self):
+        for axis in self.axes:
+            axis.grade()
+
     def copy_grading(self) -> bool:
         """Attempts to copy grading from a neighbouring block;
         returns True if the grading was copied and False in all other cases"""
@@ -132,13 +136,17 @@ def copy_grading(self) -> bool:
 
         return updated
 
+    def check_consistency(self) -> None:
+        for axis in self.axes:
+            axis.check_consistency()
+
     @property
     def indexes(self) -> IndexType:
         return [vertex.index for vertex in self.vertices]
 
     def format_grading(self) -> str:
         """Returns the simple/edgeGrading string"""
-        if all([axis.wires.is_simple for axis in self.axes]):  # is_simple
+        if all(axis.is_simple for axis in self.axes):  # is_simple
             return (
                 "simpleGrading ( "
                 + self.axes[0].wires.format_single()

src/classy_blocks/items/wires/axis.py

@@ -90,15 +90,21 @@ def copy_grading(self) -> bool:
                     for chop in reversed(neighbour.wires.chops):
                         self.wires.add_chop(chop.copy_preserving(inverted=True))
 
-                self.wires.grade()
+                self.grade()
                 return True
 
         return False
 
+    def grade(self) -> None:
+        self.wires.grade()
+
     @property
     def count(self) -> int:
         return self.wires.count
 
     @property
     def is_simple(self) -> bool:
         return self.wires.is_simple
+
+    def check_consistency(self) -> None:
+        self.wires.check_consistency()

src/classy_blocks/items/wires/manager.py

@@ -21,14 +21,20 @@ def __iter__(self):
     def add_chop(self, chop: Chop) -> None:
         self.chops.append(chop)
 
+    @abc.abstractmethod
+    def update(self) -> None:
+        """Re-set grading and wires' lengths"""
+        for wire in self.wires:
+            wire.grading.length = wire.length
+
     @abc.abstractmethod
     def grade(self) -> None:
         """Convert data from user or neighbour to Grading objects on wires"""
 
     @property
-    @abc.abstractmethod
     def is_defined(self) -> bool:
-        """Returns True if there's enough data to define a grading on this axis"""
+        """Returns True if all gradings are defined on this axis"""
+        return all(wire.grading.is_defined for wire in self.wires)
 
     @property
     @abc.abstractmethod
@@ -61,6 +67,13 @@ def is_simple(self) -> bool:
 
         return True
 
+    def check_consistency(self) -> None:
+        """Raises an error if not all wires have the same count"""
+        counts = [wire.grading.count for wire in self.wires]
+        if len(set(counts)) != 1:
+            wire_descriptions = [str(wire) for wire in self.wires]
+            raise InconsistentGradingsError(f"Inconsistent counts on wires {wire_descriptions} ({counts})")
+
 
 class WireChopManager(WireManagerBase):
     """Responsible for conversion of user-specified Chops
@@ -71,21 +84,16 @@ def __init__(self, wires: List[Wire]):
 
         # Chops and Grading that is done on the whole axis;
         # Cell count is defined here. Other values are a matter of each individual Wire.
-        self.grading = Grading(self.length)
-
-    @property
-    def is_defined(self) -> bool:
-        """True if chops have been delegated to each wire and gradings calculated"""
-        if len(self.chops) == 0:
-            return False
+        self.grading = Grading(0)
 
-        # either all wires are defined or none is
-        if not self.wires[0].grading.is_defined:
-            self.grade()
+    def update(self):
+        self.grading.length = self.length
 
-        return True
+        super().update()
 
     def grade(self) -> None:
+        self.update()
+
         # Create a proper Grading from chops
         for chop in self.chops:
             self.grading.add_chop(chop)
@@ -108,17 +116,15 @@ class WirePropagateManager(WireManagerBase):
     def __init__(self, wires: List[Wire]):
         super().__init__(wires)
 
-    @property
-    def is_defined(self):
-        return self.wires[0].grading.is_defined
+    def update(self):
+        super().update()
 
     def grade(self):
         """Checks each wire whether their coincidents (wires from other blocks)
         have grading defined already; if so, copy it and return True.
         Returns False otherwise"""
         self.copy_neighbours()
         self.propagate_grading()
-        self.check_consistency()
 
     def copy_neighbours(self) -> None:
         """Checks for defined neighbours and copies grading from them"""
@@ -148,13 +154,6 @@ def propagate_grading(self) -> None:
                 for chop in self.chops:
                     wire.grading.add_chop(chop)
 
-    def check_consistency(self):
-        """Raises an error if not all wires have the same count"""
-        counts = [wire.grading.count for wire in self.wires]
-        if len(set(counts)) != 1:
-            wire_descriptions = [str(wire) for wire in self.wires]
-            raise InconsistentGradingsError(f"Inconsistent counts on wires {wire_descriptions} ({counts})")
-
     @property
     def count(self):
         return sum(chop.results["count"] for chop in self.chops)

src/classy_blocks/lists/block_list.py

@@ -18,6 +18,10 @@ 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:
@@ -62,6 +66,10 @@ def propagate_gradings(self):
 
             raise UndefinedGradingsError(message)
 
+    def check_consistency(self):
+        for block in self.blocks:
+            block.check_consistency()
+
     def clear(self) -> None:
         """Removes created blocks"""
         self.blocks.clear()

src/classy_blocks/mesh.py

@@ -132,6 +132,14 @@ 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"""
@@ -189,7 +197,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.block_list.propagate_gradings()
+        self.grade()
 
         with open(output_path, "w", encoding="utf-8") as output:
             output.write(constants.MESH_HEADER)

tests/test_construct/test_assembly.py

@@ -75,6 +75,7 @@ def test_chop(self):
 
         mesh.add(joint)
         mesh.assemble()
+        mesh.block_list.grade_blocks()
         mesh.block_list.propagate_gradings()
 
     def test_set_patches(self):