morphopt 3.2.2__tar.gz → 4.0.1__tar.gz

{morphopt-3.2.2/src/morphopt.egg-info → morphopt-4.0.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: morphopt
-Version: 3.2.2
-Summary: A morphing optimization framework using PyTorch and Abaqus.
+Version: 4.0.1
+Summary: A morphing optimization framework using PyTorch and torchfea.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: torch>=2.9.1
@@ -16,11 +16,13 @@ Requires-Dist: gmsh>=4.15.0
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: imageio>=2.37.3
 Requires-Dist: bspmap>=1.0.3
-Requires-Dist: torchfea>=1.1.1
+Requires-Dist: torchfea>=1.1.2
 Requires-Dist: trimesh>=4.11.5
 Requires-Dist: networkx>=3.6.1
 Requires-Dist: scipy>=1.17.1
 Requires-Dist: cpgeo>=1.0.12
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
 
 # MorphOpt — A Differentiable Optimization Framework for Soft Structure & Morphology Design
 
@@ -72,7 +74,13 @@ Requirements: Python ≥ 3.12; a PyTorch **float64** build is recommended.
    # python -m morphopt.ui works too (handy when running from a source code directory)
    ```
 
-The complete UI workflow (definition part + observer part) is described in [`docs/UI_usage.md`](docs/UI_usage.md).
+The GUI opens directly into the full definition workbench with its standard sections present and no problem setup prefilled. Build a definition yourself or use **Quickstart** to choose shape or topology optimization, define geometry separately, and add weighted objective terms with their own load conditions. Workspace terms select their driving pressure channels and use boundary integration. Generated problems stay editable and can be saved or exported as runnable scripts.
+
+The complete UI workflow (definition part + observer part) is described in [`docs/UIguide.md`](docs/UIguide.md).
+
+### Numeric configuration
+
+Shared UI defaults and tunable kernel parameters live in [`src/morphopt/constants.py`](src/morphopt/constants.py), grouped under `CONSTANT.UI` and `CONSTANT.KERNEL`. Code accesses them directly, for example `CONSTANT.UI.VIEWER.RENDER.LABEL_FONT_SIZE` or `CONSTANT.KERNEL.SOLVER.NUM_PROCESS`. Edit a value there to change its default; restart MorphOpt for the change to take effect. Coordinate indices, tensor dimensions, and coefficients that define mathematical formulas remain in code. UI translations remain in JSON files under `src/morphopt/ui/locales/`.
 
 Further references:
 

morphopt-3.2.2/PKG-INFO → morphopt-4.0.1/README.md

@@ -1,27 +1,3 @@
-Metadata-Version: 2.4
-Name: morphopt
-Version: 3.2.2
-Summary: A morphing optimization framework using PyTorch and Abaqus.
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-Requires-Dist: torch>=2.9.1
-Requires-Dist: torchvision>=0.15.1
-Requires-Dist: numpy>=2.0.0
-Requires-Dist: pypardiso>=0.4.7
-Requires-Dist: pyside6>=6.8.0
-Requires-Dist: pyvista>=0.47.1
-Requires-Dist: pyvistaqt>=0.11.3
-Requires-Dist: vtk>=9.6.1
-Requires-Dist: gmsh>=4.15.0
-Requires-Dist: tabulate>=0.9.0
-Requires-Dist: imageio>=2.37.3
-Requires-Dist: bspmap>=1.0.3
-Requires-Dist: torchfea>=1.1.1
-Requires-Dist: trimesh>=4.11.5
-Requires-Dist: networkx>=3.6.1
-Requires-Dist: scipy>=1.17.1
-Requires-Dist: cpgeo>=1.0.12
-
 # MorphOpt — A Differentiable Optimization Framework for Soft Structure & Morphology Design
 
 **Developed by Zenan Song**
@@ -72,7 +48,13 @@ Requirements: Python ≥ 3.12; a PyTorch **float64** build is recommended.
    # python -m morphopt.ui works too (handy when running from a source code directory)
    ```
 
-The complete UI workflow (definition part + observer part) is described in [`docs/UI_usage.md`](docs/UI_usage.md).
+The GUI opens directly into the full definition workbench with its standard sections present and no problem setup prefilled. Build a definition yourself or use **Quickstart** to choose shape or topology optimization, define geometry separately, and add weighted objective terms with their own load conditions. Workspace terms select their driving pressure channels and use boundary integration. Generated problems stay editable and can be saved or exported as runnable scripts.
+
+The complete UI workflow (definition part + observer part) is described in [`docs/UIguide.md`](docs/UIguide.md).
+
+### Numeric configuration
+
+Shared UI defaults and tunable kernel parameters live in [`src/morphopt/constants.py`](src/morphopt/constants.py), grouped under `CONSTANT.UI` and `CONSTANT.KERNEL`. Code accesses them directly, for example `CONSTANT.UI.VIEWER.RENDER.LABEL_FONT_SIZE` or `CONSTANT.KERNEL.SOLVER.NUM_PROCESS`. Edit a value there to change its default; restart MorphOpt for the change to take effect. Coordinate indices, tensor dimensions, and coefficients that define mathematical formulas remain in code. UI translations remain in JSON files under `src/morphopt/ui/locales/`.
 
 Further references:
 

{morphopt-3.2.2 → morphopt-4.0.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "morphopt"
-version = "3.2.2"
-description = "A morphing optimization framework using PyTorch and Abaqus."
+version = "4.0.1"
+description = "A morphing optimization framework using PyTorch and torchfea."
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
@@ -17,7 +17,7 @@ dependencies = [
     "tabulate>=0.9.0",
     "imageio>=2.37.3",
     "bspmap>=1.0.3",
-    "torchfea>=1.1.1",
+    "torchfea>=1.1.2",
     "trimesh>=4.11.5",
     "networkx>=3.6.1",
     "scipy>=1.17.1",
@@ -27,3 +27,23 @@ dependencies = [
 [project.scripts]
 # console entry for the graphical UI (after `pip install morphopt`)
 morphopt-ui = "morphopt.ui:run_app"
+
+[project.optional-dependencies]
+# Install with: python -m pip install -e ".[test]"
+test = [
+    "pytest>=8.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-ra"
+
+[tool.ruff.lint]
+extend-select = ["RUF022"]
+
+[tool.setuptools.package-data]
+"morphopt.ui" = [
+    "locales/*.json",
+    "theme/styles/*.qss",
+]

{morphopt-3.2.2 → morphopt-4.0.1}/src/morphopt/__init__.py

@@ -13,6 +13,7 @@ if __sys.platform.startswith("linux"):
 # region: Logging Configuration
 import logging as __logging
 
+
 def enable_logging(level=__logging.INFO, log_file=None, file_log_level=__logging.DEBUG):
     """
     Enable logging for the FEA package.
@@ -25,7 +26,7 @@ def enable_logging(level=__logging.INFO, log_file=None, file_log_level=__logging
         the path to a log file where logs will be written. If None, logs will only be printed to the console.
     file_log_level : int
         the logging level for the log file. Default is logging.INFO.
-    
+
     Examples
     --------
     >>> import torchfea
@@ -33,59 +34,81 @@ def enable_logging(level=__logging.INFO, log_file=None, file_log_level=__logging
     """
     logger = __logging.getLogger(__name__)
     logger.setLevel(min(level, file_log_level))
-    
+
     # clear existing handlers to avoid duplicate logs
     logger.handlers.clear()
-    
+
     # logging to console
     console = __logging.StreamHandler()
     console.setLevel(level)
-    console.setFormatter(__logging.Formatter(
-        '%(asctime)s | %(levelname)-7s | %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    ))
+    console.setFormatter(
+        __logging.Formatter(
+            "%(asctime)s | %(levelname)-7s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+        )
+    )
     logger.addHandler(console)
-    
+
     # logging to file if log_file is provided
     if log_file:
-        file_handler = __logging.FileHandler(log_file, encoding='utf-8')
+        file_handler = __logging.FileHandler(log_file, encoding="utf-8")
         file_handler.setLevel(file_log_level)
-        file_handler.setFormatter(__logging.Formatter(
-            '%(asctime)s | %(levelname)-7s | %(name)s | %(message)s'
-        ))
+        file_handler.setFormatter(
+            __logging.Formatter(
+                "%(asctime)s | %(levelname)-7s | %(name)s | %(message)s"
+            )
+        )
         logger.addHandler(file_handler)
 
     return logger
-# endregion
-
 
 
+# endregion
 
 
-# region optcore imports
+# region modules (loaded after the core classes they subclass)
+from . import codesign, shapeopt, simp
+from .opt_runner import debug_optimization, start_optimization
 from .optcore.controller import Controller
+from .optcore.history import History
 from .optcore.modelparams import (
-    FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry,
-    MaterialsParams, Params,
+    BaseModelComponent,
+    BasePart,
+    CADPart,
+    BoxPart,
+    FEAParams,
+    GeometryParams,
+    INPPart,
+    MaterialsParams,
+    Params,
+    TorchFEAPart,
+    load_model_assembly,
+    resolve_model_path,
+)
+from .optcore.modelparams.materials import HomogeneousMaterial
+from .optcore.objfunc import ObjectiveFunction
+from .optcore.protocal import (
+    ProtocalInitializable,
+    ProtocalSavable,
+    ProtocalUpdatable,
+    ProtocalVisualizable,
 )
 from .optcore.solver import Solver
-from .optcore.modelparams import Params
 from .optcore.updaters import Updaters
-from .optcore.objfunc import ObjectiveFunction
-from .optcore.history import History
-from .optcore.baseobject import BaseObject
-# endregion
-
-from .opt_runner import start_optimization, debug_optimization
+from .shapeopt import (
+    BoundaryPart,
+    UpdaterBoundaryPart,
+    BaseSurfaceConstraints,
+    SurfaceRelationConstraint,
+    BspSurfaceRelationConstraint,
+    CPGEOSurfaceRelationConstraint,
+)
+from .codesign import OffsetBoundaryPart, UpdaterOffsetBoundaryPart
+from .simp import SIMP_BSPFieldMaterials, UpdaterSIMPMaterial
 
-# region modules
-from . import shapeopt
-from . import codesign
-from . import simp
 # endregion
-
 # region scripts
 from .utils import check_gradients, get_controller
+
 # endregion
 
 controller: Controller = None

morphopt-4.0.1/src/morphopt/codesign/__init__.py

@@ -0,0 +1,16 @@
+"""Cavity offset Parts and their geometry updater.
+
+Compose parameters, objectives, solvers and updater collections using the
+common morphopt interfaces. SIMP materials use the simp interfaces.
+"""
+
+from .offset_boundary_part import OffsetBoundaryPart
+from .update_offset_boundary_part import UpdaterOffsetBoundaryPart
+from .constraints import InwardCurvatureRadius, OffsetSurfaceMinThickness
+
+__all__ = [
+    "OffsetBoundaryPart",
+    "UpdaterOffsetBoundaryPart",
+    "InwardCurvatureRadius",
+    "OffsetSurfaceMinThickness",
+]

{morphopt-3.2.2 → morphopt-4.0.1}/src/morphopt/codesign/constraints.py

@@ -1,7 +1,8 @@
 import torch
 
+from ..constants import CONSTANT
 from ..shapeopt.objectivefuncs.basefuncs import BaseConstraints
-from .geometry import CodesignGeometry
+from .offset_boundary_part import OffsetBoundaryPart
 
 
 class InwardCurvatureRadius(BaseConstraints):
@@ -15,23 +16,21 @@ class InwardCurvatureRadius(BaseConstraints):
 
     def __init__(
         self,
-        geometry: CodesignGeometry,
         surface_start: int = 1,
         surface_ids: list[int] | None = None,
-        margin: float = 0.4,
-        margin_ratio: float = 0.45,
-        barrier_thre_ratio: float = 0.1,
-        barrier_ratio: float = 0.0,
-        p: int = 8,
-        penalty_scale: float = 1e3,
-        hard_violation_beta: float = 8.0,
+        margin: float = CONSTANT.KERNEL.CODESIGN.CURVATURE_MARGIN,
+        margin_ratio: float = CONSTANT.KERNEL.CODESIGN.CURVATURE_MARGIN_RATIO,
+        barrier_thre_ratio: float = CONSTANT.KERNEL.CODESIGN.CURVATURE_BARRIER_THRESHOLD_RATIO,
+        barrier_ratio: float = CONSTANT.KERNEL.CODESIGN.BARRIER_PENALTY_RATIO,
+        p: int = CONSTANT.KERNEL.CODESIGN.BARRIER_EXPONENT,
+        penalty_scale: float = CONSTANT.KERNEL.CODESIGN.PENALTY_SCALE,
+        hard_violation_beta: float = CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_BETA,
         normal_sign: float = 1.0,
     ) -> None:
         """
         Initialize the inward curvature radius constraint.
 
         Args:
-            geometry (CodesignGeometry): The geometry parameters containing the surfaces.
             surface_start (int, optional): The starting index of surfaces to apply the constraint. Defaults to 1.
             surface_ids (list[int] | None, optional): The specific surface indices to apply the constraint. If None, applies to all surfaces starting from surface_start. Defaults to None.
             margin (float, optional): The absolute margin added to thickness for curvature limit. Defaults to 0.4.
@@ -42,17 +41,16 @@ class InwardCurvatureRadius(BaseConstraints):
             penalty_scale (float, optional): Global multiplier for this constraint penalty. Defaults to 1e3.
             hard_violation_beta (float, optional): Exponential amplification factor for large violations. Defaults to 8.0.
             normal_sign (float, optional): The sign to determine inward direction. Use 1.0 if normals point outward, -1.0 if normals point inward. Defaults to 1.0.
-        
-        """
 
+        """
 
         super().__init__()
 
-        self.geometry = geometry
-        """Stores the geometry used by InwardCurvatureRadius."""
         self.surface_start = int(surface_start)
         """Stores the surface start used by InwardCurvatureRadius."""
-        self.surface_ids = None if surface_ids is None else [int(i) for i in surface_ids]
+        self.surface_ids = (
+            None if surface_ids is None else [int(i) for i in surface_ids]
+        )
         """Stores the surface ids used by InwardCurvatureRadius."""
 
         self.margin = margin
@@ -73,7 +71,11 @@ class InwardCurvatureRadius(BaseConstraints):
         """Stores the normal sign used by InwardCurvatureRadius."""
 
     @staticmethod
-    def _principal_curvatures(rdu: torch.Tensor, rdu2: torch.Tensor, eps: float = 1e-12) -> tuple[torch.Tensor, torch.Tensor]:
+    def _principal_curvatures(
+        rdu: torch.Tensor,
+        rdu2: torch.Tensor,
+        eps: float = CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         normal0 = torch.cross(rdu[:, :, 1], rdu[:, :, 0], dim=1)
         normal = normal0 / (normal0.norm(dim=1, keepdim=True) + eps)
 
@@ -93,26 +95,51 @@ class InwardCurvatureRadius(BaseConstraints):
         k2 = 0.5 * (tr - root)
         return k1, k2
 
+    def initialize(self, r0, rdu0, *args, part_interface=None, **kwargs) -> None:
+        """Take the Part this constraint is evaluated for.
+
+        The geometry updater hands over the Part it evaluates; only a
+        :class:`~morphopt.codesign.OffsetBoundaryPart` carries a
+        shell, so anything else is rejected here.
+        """
+        super().initialize(r0=r0, rdu0=rdu0, *args, **kwargs)
+        if not isinstance(part_interface, OffsetBoundaryPart):
+            raise TypeError(
+                f"{type(self).__name__} is evaluated for one co-design Part "
+                f"(got {type(part_interface).__name__})."
+            )
+        self.shell_thickness = float(part_interface.shell_thickness)
+
     def _selected_surface_ids(self, n_surface: int) -> list[int]:
         if self.surface_ids is None:
             return [i for i in range(max(self.surface_start, 0), n_surface)]
         return [i for i in self.surface_ids if 0 <= i < n_surface]
 
-    def __call__(self, r: list[torch.Tensor], rdu: list[torch.Tensor], rdu2: list[torch.Tensor], *args, **kwargs) -> torch.Tensor:
+    def __call__(
+        self,
+        r: list[torch.Tensor],
+        rdu: list[torch.Tensor],
+        rdu2: list[torch.Tensor],
+        *args,
+        **kwargs,
+    ) -> torch.Tensor:
         loss = torch.zeros(1, device=r[0].device, dtype=r[0].dtype)
 
-        t = float(self.geometry.shell_thickness)
-        if t <= 0:
-            return loss
-
-        margin_abs = (self.margin_ratio * t) + self.margin
-        margin_abs = max(float(margin_abs), 1e-12)
-        t_eff = t + margin_abs
+        for i in self._selected_surface_ids(len(r)):
+            t = self.shell_thickness
+            if t <= 0:
+                continue
 
-        k_limit = 1.0 / t_eff
-        barrier_thre = max(k_limit * self.barrier_thre_ratio, 1e-12)
+            margin_abs = max(
+                float((self.margin_ratio * t) + self.margin),
+                CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
+            )
+            k_limit = 1.0 / (t + margin_abs)
+            barrier_thre = max(
+                k_limit * self.barrier_thre_ratio,
+                CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
+            )
 
-        for i in self._selected_surface_ids(len(r)):
             k1, k2 = self._principal_curvatures(rdu[i], rdu2[i])
 
             k1_in = torch.relu(self.normal_sign * k1)
@@ -120,16 +147,24 @@ class InwardCurvatureRadius(BaseConstraints):
             k_inward = torch.maximum(k1_in, k2_in)
 
             violation = k_inward - k_limit
-            index, penalty = self.barrier_function(violation, barrier_thre, self.barrier_ratio, self.p)
+            index, penalty = self.barrier_function(
+                violation, barrier_thre, self.barrier_ratio, self.p
+            )
             if index.numel() > 0:
                 # Strong amplification: base polynomial barrier + exponential hard-violation boost.
                 rel_violation = (violation[index] / barrier_thre).clamp(min=0.0)
-                hard_boost = torch.exp((self.hard_violation_beta * (rel_violation - 1.0)).clamp(min=0.0, max=20.0))
+                hard_boost = torch.exp(
+                    (self.hard_violation_beta * (rel_violation - 1.0)).clamp(
+                        min=0.0,
+                        max=CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_EXPONENT_MAX,
+                    )
+                )
                 penalty_strong = self.penalty_scale * penalty * hard_boost
                 loss = loss + (self.scaler[i][index] * penalty_strong).sum()
 
         return loss
 
+
 class OffsetSurfaceMinThickness(BaseConstraints):
     """
     Enforce a minimum distance on the offset surface to reduce self-intersection risk.
@@ -140,28 +175,36 @@ class OffsetSurfaceMinThickness(BaseConstraints):
 
     def __init__(
         self,
-        geometry: CodesignGeometry,
         surface_start: int = 1,
         surface_ids: list[int] | None = None,
         min_distance: float | None = None,
-        search_ratio: float = 1.5,
-        barrier_thre_ratio: float = 0.05,
-        barrier_ratio: float = 0.0,
-        p: int = 8,
-        penalty_scale: float = 1e3,
-        hard_violation_beta: float = 8.0,
+        search_ratio: float = CONSTANT.KERNEL.CODESIGN.THICKNESS_SEARCH_RATIO,
+        barrier_thre_ratio: float = CONSTANT.KERNEL.CODESIGN.THICKNESS_BARRIER_THRESHOLD_RATIO,
+        barrier_ratio: float = CONSTANT.KERNEL.CODESIGN.BARRIER_PENALTY_RATIO,
+        p: int = CONSTANT.KERNEL.CODESIGN.BARRIER_EXPONENT,
+        penalty_scale: float = CONSTANT.KERNEL.CODESIGN.PENALTY_SCALE,
+        hard_violation_beta: float = CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_BETA,
         normal_sign: float = 1.0,
-        normal_opposition_thre: float = 0.0,
-        normal_min: float = -0.7,
-        normal_max: float = -0.5,
+        normal_opposition_thre: float = CONSTANT.KERNEL.CODESIGN.NORMAL_OPPOSITION_THRESHOLD,
+        normal_min: float = CONSTANT.KERNEL.CODESIGN.NORMAL_TRANSITION_MIN,
+        normal_max: float = CONSTANT.KERNEL.CODESIGN.NORMAL_TRANSITION_MAX,
     ) -> None:
+        """
+        Initialize the minimum thickness constraint for the offset surface.
+
+        Args:
+            surface_start (int, optional): The starting index of surfaces to apply the constraint. Defaults to 1.
+            surface_ids (list[int] | None, optional): The specific surface indices to apply the constraint. If None, applies to all surfaces starting from surface_start. Defaults to None.
+            min_distance (float | None, optional): The required minimum distance.
+                Defaults to twice the shell thickness.
+        """
         super().__init__()
 
-        self.geometry = geometry
-        """Stores the geometry used by OffsetSurfaceMinThickness."""
         self.surface_start = int(surface_start)
         """Stores the surface start used by OffsetSurfaceMinThickness."""
-        self.surface_ids = None if surface_ids is None else [int(i) for i in surface_ids]
+        self.surface_ids = (
+            None if surface_ids is None else [int(i) for i in surface_ids]
+        )
         """Stores the surface ids used by OffsetSurfaceMinThickness."""
 
         self.min_distance = min_distance
@@ -200,36 +243,66 @@ class OffsetSurfaceMinThickness(BaseConstraints):
     @staticmethod
     def _surface_normals(rdu_sf: torch.Tensor) -> torch.Tensor:
         normal0 = torch.cross(rdu_sf[:, :, 1], rdu_sf[:, :, 0], dim=1)
-        normals = normal0 / (normal0.norm(dim=1, keepdim=True) + 1e-12)
+        normals = normal0 / (
+            normal0.norm(dim=1, keepdim=True)
+            + CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE
+        )
         return normals
 
-    def _offset_points(self, r_sf: torch.Tensor, rdu_sf: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def _offset_points(
+        self, r_sf: torch.Tensor, rdu_sf: torch.Tensor, thickness: float
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Offset surface points and the normals they were offset along."""
         normals = self._surface_normals(rdu_sf=rdu_sf)
-        thickness = float(self.geometry.shell_thickness)
         return r_sf + self.normal_sign * thickness * normals, normals
 
-    def initialize(self, r0, rdu0, *args, **kwargs) -> None:
+    def _min_distance(self, thickness: float) -> float:
+        dmin = (
+            float(self.min_distance)
+            if self.min_distance is not None
+            else (2.0 * thickness)
+        )
+        return max(dmin, CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE)
+
+    def initialize(self, r0, rdu0, *args, part_interface=None, **kwargs) -> None:
+        """Take the Part this constraint is evaluated for and pair its points.
+
+        The geometry updater hands over the Part it evaluates; only a
+        :class:`~morphopt.codesign.OffsetBoundaryPart` carries a
+        shell, so anything else is rejected here.
+        """
         super().initialize(r0=r0, rdu0=rdu0, *args, **kwargs)
+        if not isinstance(part_interface, OffsetBoundaryPart):
+            raise TypeError(
+                f"{type(self).__name__} is evaluated for one co-design Part "
+                f"(got {type(part_interface).__name__})."
+            )
+        self.shell_thickness = float(part_interface.shell_thickness)
 
         self._neighbor_pairs = {}
         self._neighbor_mindist = {}
 
-        import scipy.spatial
+        if self.shell_thickness <= 0:
+            return
 
-        thickness = float(self.geometry.shell_thickness)
-        dmin = float(self.min_distance) if self.min_distance is not None else (2.0 * thickness)
-        dmin = max(dmin, 1e-12)
-        search_radius = max(dmin * self.search_ratio, dmin)
+        import scipy.spatial
 
         for sf_idx in self._selected_surface_ids(len(r0)):
-            roff, normals = self._offset_points(r_sf=r0[sf_idx], rdu_sf=rdu0[sf_idx])
+            dmin = self._min_distance(self.shell_thickness)
+            search_radius = max(dmin * self.search_ratio, dmin)
+
+            roff, normals = self._offset_points(
+                r_sf=r0[sf_idx], rdu_sf=rdu0[sf_idx], thickness=self.shell_thickness
+            )
 
             tree = scipy.spatial.KDTree(roff.detach().cpu().numpy())
-            pairs_np = tree.query_pairs(r=search_radius, output_type='ndarray')
+            pairs_np = tree.query_pairs(r=search_radius, output_type="ndarray")
             if pairs_np.size == 0:
                 continue
 
-            pairs = torch.from_numpy(pairs_np.T).to(dtype=torch.int64, device=r0[sf_idx].device)
+            pairs = torch.from_numpy(pairs_np.T).to(
+                dtype=torch.int64, device=r0[sf_idx].device
+            )
 
             dotn = (normals[pairs[0]] * normals[pairs[1]]).sum(dim=1)
             opposition = (-dotn).clamp(min=0.0)
@@ -239,22 +312,29 @@ class OffsetSurfaceMinThickness(BaseConstraints):
                 self._neighbor_pairs[sf_idx] = pairs
                 self._neighbor_mindist[sf_idx] = dmin * opposition[keep]
 
-    def __call__(self, r: list[torch.Tensor], rdu: list[torch.Tensor], rdu2: list[torch.Tensor], *args, **kwargs) -> torch.Tensor:
+    def __call__(
+        self,
+        r: list[torch.Tensor],
+        rdu: list[torch.Tensor],
+        rdu2: list[torch.Tensor],
+        *args,
+        **kwargs,
+    ) -> torch.Tensor:
         loss = torch.zeros(1, device=r[0].device, dtype=r[0].dtype)
 
-        if float(self.geometry.shell_thickness) <= 0:
-            return loss
-
-        thickness = float(self.geometry.shell_thickness)
-        dmin = float(self.min_distance) if self.min_distance is not None else (2.0 * thickness)
-        dmin = max(dmin, 1e-12)
-        barrier_thre = max(dmin * self.barrier_thre_ratio, 1e-12)
-
         for sf_idx in self._selected_surface_ids(len(r)):
             pairs = self._neighbor_pairs.get(sf_idx, None)
             if pairs is None or pairs.numel() == 0:
                 continue
 
+            thickness = self.shell_thickness
+            if thickness <= 0:
+                continue
+            barrier_thre = max(
+                self._min_distance(thickness) * self.barrier_thre_ratio,
+                CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
+            )
+
             # Base surface normals (offset surface shares same normal direction)
             normals = self._surface_normals(rdu_sf=rdu[sf_idx])
             dotn = (normals[pairs[0]] * normals[pairs[1]]).sum(dim=1)
@@ -267,27 +347,46 @@ class OffsetSurfaceMinThickness(BaseConstraints):
             pairs_n = pairs[:, mask_n]
             dotn_n = dotn[mask_n]
             mindist_n = self._neighbor_mindist[sf_idx][mask_n].to(
-                device=r[sf_idx].device, dtype=r[sf_idx].dtype)
+                device=r[sf_idx].device, dtype=r[sf_idx].dtype
+            )
             scaler_n0 = self.scaler[sf_idx][pairs_n[0]]
             scaler_n1 = self.scaler[sf_idx][pairs_n[1]]
 
             # Offset points and distance
-            roff, _ = self._offset_points(r_sf=r[sf_idx], rdu_sf=rdu[sf_idx])
+            roff, _ = self._offset_points(
+                r_sf=r[sf_idx], rdu_sf=rdu[sf_idx], thickness=thickness
+            )
             delta = roff[pairs_n[0]] - roff[pairs_n[1]]
-            dist = torch.sqrt((delta * delta).sum(dim=1) + 1e-18)
+            dist = torch.sqrt(
+                (delta * delta).sum(dim=1)
+                + CONSTANT.KERNEL.CODESIGN.DISTANCE_SQUARED_TOLERANCE
+            )
 
             violation = mindist_n - dist + barrier_thre
-            indexl, l = self.barrier_function(violation, barrier_thre, self.barrier_ratio, self.p)
+            indexl, l = self.barrier_function(
+                violation, barrier_thre, self.barrier_ratio, self.p
+            )
 
             if indexl.numel() > 0:
                 # Smooth normal penalty (same as Distance class)
-                np_val = (self.normal_max - torch.clamp(dotn_n[indexl], self.normal_min, self.normal_max)) / (self.normal_max - self.normal_min)
+                np_val = (
+                    self.normal_max
+                    - torch.clamp(dotn_n[indexl], self.normal_min, self.normal_max)
+                ) / (self.normal_max - self.normal_min)
                 np_smooth = (6 * np_val**2 - 15 * np_val + 10) * np_val**3
 
                 rel_violation = (violation[indexl] / barrier_thre).clamp(min=0.0)
-                hard_boost = torch.exp((self.hard_violation_beta * (rel_violation - 1.0)).clamp(min=0.0, max=20.0))
+                hard_boost = torch.exp(
+                    (self.hard_violation_beta * (rel_violation - 1.0)).clamp(
+                        min=0.0,
+                        max=CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_EXPONENT_MAX,
+                    )
+                )
                 penalty_strong = self.penalty_scale * l * hard_boost * np_smooth
 
-                loss = loss + (penalty_strong * scaler_n0[indexl] * scaler_n1[indexl]).sum()
+                loss = (
+                    loss
+                    + (penalty_strong * scaler_n0[indexl] * scaler_n1[indexl]).sum()
+                )
 
         return loss