Remove grading params from user interface;

Users now only have to import the appropriate grader.
Also, sort out confusion with exceptions and whatnot.
Also also, cleanup some TODO work

Author: FranzBangar

examples/advanced/autograding_highre.py

@@ -2,7 +2,6 @@
 
 import classy_blocks as cb
 from classy_blocks.grading.autograding.grader import HighReGrader
-from classy_blocks.grading.autograding.params import HighReChopParams
 
 mesh = cb.Mesh()
 
@@ -19,18 +18,12 @@
     vertex = list(finder.find_in_sphere(point))[0]
     vertex.translate([0, 0.8, 0])
 
-# TODO! Un-hack
-mesh.block_list.update()
-
 mesh.set_default_patch("walls", "wall")
 
+# TODO: Hack! mesh.assemble() won't work here but wires et. al. must be updated
+mesh.block_list.update()
 
-params = HighReChopParams(0.05)
-grader = HighReGrader(mesh, params)
+grader = HighReGrader(mesh, 0.05)
 grader.grade()
 
-# params = SimpleChopParams(0.05)
-# grader = SimpleGrader(mesh, params)
-# grader.grade(take="max")
-
 mesh.write(os.path.join("..", "case", "system", "blockMeshDict"), debug_path="debug.vtk")

examples/advanced/low_re_chops.py

@@ -15,15 +15,12 @@
     T_PIPE,
 )
 
+from classy_blocks.base.exceptions import GeometryConstraintError
 from classy_blocks.types import NPPointType
 from classy_blocks.util import functions as f
 from classy_blocks.util.constants import vector_format as fvect
 
 
-class GeometryConstraintError(Exception):
-    """Raised when input parameters produce an invalid geometry"""
-
-
 @dataclasses.dataclass
 class Geometry:
     """Holds user-provided parameters and conversions to SI units;

examples/complex/cyclone/geometry.py

@@ -3,7 +3,6 @@
 import classy_blocks as cb
 from classy_blocks.construct.flat.sketches.disk import QuarterDisk
 from classy_blocks.grading.autograding.grader import HighReGrader
-from classy_blocks.grading.autograding.params import HighReChopParams
 from classy_blocks.util import functions as f
 
 mesh = cb.Mesh()
@@ -21,11 +20,8 @@
 mesh.add(quarter_cylinder)
 
 mesh.assemble()
-# TODO: automate or something
-mesh.block_list.update()
 
-params = HighReChopParams(0.05)
-grader = HighReGrader(mesh, params)
+grader = HighReGrader(mesh, 0.05)
 grader.grade()
 
 

examples/shape/quarter_cylinder.py

@@ -1,27 +1,7 @@
 from typing import Optional
 
 
-class VertexNotFoundError(Exception):
-    """Raised when a vertex at a given point in space doesn't exist yet"""
-
-
-class EdgeNotFoundError(Exception):
-    """Raised when an edge between a given pair of vertices doesn't exist yet"""
-
-
-class CornerPairError(Exception):
-    """Raised when given pair of corners is not valid (for example, edge between 0 and 2)"""
-
-
-class UndefinedGradingsError(Exception):
-    """Raised when the user hasn't supplied enough grading data to
-    define all blocks in the mesh"""
-
-
-class InconsistentGradingsError(Exception):
-    """Raised when cell counts for edges on the same axis is not consistent"""
-
-
+### Construction
 class ShapeCreationError(Exception):
     """Base class for shape creation errors (invalid parameters/types to
     shape constructors)"""
@@ -75,3 +55,80 @@ class FrustumCreationError(ShapeCreationError):
 
 class ExtrudedRingCreationError(ShapeCreationError):
     pass
+
+
+class GeometryConstraintError(Exception):
+    """Raised when input parameters produce an invalid geometry"""
+
+
+class DegenerateGeometryError(Exception):
+    """Raised when orienting failed because of invalid geometry"""
+
+
+# Shell/offsetting logic
+class SharedPointError(Exception):
+    """Errors with shared points"""
+
+
+class SharedPointNotFoundError(SharedPointError):
+    pass
+
+
+class PointNotCoincidentError(SharedPointError):
+    pass
+
+
+class DisconnectedChopError(SharedPointError):
+    """Issued when chopping a Shell that has disconnected faces"""
+
+
+### Search/retrieval
+class VertexNotFoundError(Exception):
+    """Raised when a vertex at a given point in space doesn't exist yet"""
+
+
+class EdgeNotFoundError(Exception):
+    """Raised when an edge between a given pair of vertices doesn't exist yet"""
+
+
+class CornerPairError(Exception):
+    """Raised when given pair of corners is not valid (for example, edge between 0 and 2)"""
+
+
+### Grading
+class UndefinedGradingsError(Exception):
+    """Raised when the user hasn't supplied enough grading data to
+    define all blocks in the mesh"""
+
+
+class InconsistentGradingsError(Exception):
+    """Raised when cell counts for edges on the same axis is not consistent"""
+
+
+class NoInstructionError(Exception):
+    """Raised when building a catalogue"""
+
+
+class BlockNotFoundError(Exception):
+    """Raised when building a catalogue"""
+
+
+### Optimization
+class NoClampError(Exception):
+    """Raised when there's no junction defined for a given Clamp"""
+
+
+class ClampExistsError(Exception):
+    """Raised when adding a clamp to a junction that already has one defined"""
+
+
+class NoCommonSidesError(Exception):
+    """Raised when two cells don't share a side"""
+
+
+class NoJunctionError(Exception):
+    """Raised when there's a clamp defined for a vertex that doesn't exist"""
+
+
+class InvalidLinkError(Exception):
+    """Raised when a link has been added that doesn't connect two actual points"""

src/classy_blocks/base/exceptions.py

@@ -6,6 +6,7 @@
 import numpy as np
 
 from classy_blocks.base.element import ElementBase
+from classy_blocks.base.exceptions import ShapeCreationError
 from classy_blocks.construct.edges import Angle
 from classy_blocks.construct.flat.sketch import Sketch, SketchT
 from classy_blocks.construct.operations.loft import Loft
@@ -16,10 +17,6 @@
 ShapeT = TypeVar("ShapeT", bound="Shape")
 
 
-class ShapeCreationError(Exception):
-    """Raised when creating a shape from errorneous data"""
-
-
 class Shape(ElementBase, abc.ABC):
     """A collection of Operations that form a predefined
     parametric shape"""

src/classy_blocks/construct/shape.py

@@ -3,6 +3,7 @@
 
 import numpy as np
 
+from classy_blocks.base.exceptions import DisconnectedChopError, PointNotCoincidentError, SharedPointNotFoundError
 from classy_blocks.construct.flat.face import Face
 from classy_blocks.construct.operations.loft import Loft
 from classy_blocks.construct.point import Point
@@ -11,22 +12,6 @@
 from classy_blocks.util import functions as f
 
 
-class SharedPointError(Exception):
-    """Errors with shared points"""
-
-
-class SharedPointNotFoundError(SharedPointError):
-    pass
-
-
-class PointNotCoincidentError(SharedPointError):
-    pass
-
-
-class DisconnectedChopError(SharedPointError):
-    """Issued when chopping a Shell that has disconnected faces"""
-
-
 class SharedPoint:
     """A Point with knowledge of its "owner" Face(s)"""
 

src/classy_blocks/construct/shapes/shell.py

@@ -70,8 +70,8 @@ class FixedCountGrader(GraderBase):
 
     stages = 1
 
-    def __init__(self, mesh: Mesh, params: FixedCountParams):
-        super().__init__(mesh, params)
+    def __init__(self, mesh: Mesh, count: int = 8):
+        super().__init__(mesh, FixedCountParams(count))
 
 
 class SimpleGrader(GraderBase):
@@ -81,8 +81,8 @@ class SimpleGrader(GraderBase):
 
     stages = 1
 
-    def __init__(self, mesh: Mesh, params: SimpleChopParams):
-        super().__init__(mesh, params)
+    def __init__(self, mesh: Mesh, cell_size: float):
+        super().__init__(mesh, SimpleChopParams(cell_size))
 
 
 class HighReGrader(GraderBase):
@@ -93,5 +93,5 @@ class HighReGrader(GraderBase):
 
     stages = 3
 
-    def __init__(self, mesh: Mesh, params: HighReChopParams):
-        super().__init__(mesh, params)
+    def __init__(self, mesh: Mesh, cell_size: float):
+        super().__init__(mesh, HighReChopParams(cell_size))

src/classy_blocks/grading/autograding/grader.py

@@ -1,6 +1,7 @@
 import functools
 from typing import Dict, List, Optional, get_args
 
+from classy_blocks.base.exceptions import BlockNotFoundError, NoInstructionError
 from classy_blocks.items.block import Block
 from classy_blocks.items.wires.axis import Axis
 from classy_blocks.items.wires.wire import Wire
@@ -109,7 +110,7 @@ def _find_instruction(self, block: Block):
             if instruction.block == block:
                 return instruction
 
-        raise RuntimeError(f"No instruction found for block {block}")
+        raise NoInstructionError(f"No instruction found for block {block}")
 
     def _add_block_to_row(self, row: Row, instruction: Instruction, direction: DirectionType) -> None:
         row.add_block(instruction.block, direction)
@@ -142,8 +143,7 @@ def get_row_blocks(self, block: Block, direction: DirectionType) -> List[Block]:
             if block in row.blocks:
                 return row.blocks
 
-        # TODO: make a custom exception
-        raise RuntimeError(f"Direction {direction} of {block} not in catalogue")
+        raise BlockNotFoundError(f"Direction {direction} of {block} not in catalogue")
 
 
 class Probe:

src/classy_blocks/grading/autograding/probe.py

@@ -39,6 +39,7 @@
 import warnings
 from typing import List
 
+from classy_blocks.base.exceptions import UndefinedGradingsError
 from classy_blocks.grading.chop import Chop, ChopData
 from classy_blocks.types import GradingSpecType
 from classy_blocks.util import constants
@@ -150,7 +151,7 @@ def is_defined(self) -> bool:
     def description(self) -> str:
         """Output string for blockMeshDict"""
         if not self.is_defined:
-            raise ValueError(f"Grading not defined: {self}")
+            raise UndefinedGradingsError(f"Grading not defined: {self}")
 
         if len(self.specification) == 1:
             # its a one-number simpleGrading: