morphopt 4.0.0__tar.gz → 4.0.1__tar.gz

{morphopt-4.0.0 → morphopt-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphopt
-Version: 4.0.0
+Version: 4.0.1
 Summary: A morphing optimization framework using PyTorch and torchfea.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -74,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-4.0.0 → morphopt-4.0.1}/README.md

@@ -48,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-4.0.0 → morphopt-4.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "morphopt"
-version = "4.0.0"
+version = "4.0.1"
 description = "A morphing optimization framework using PyTorch and torchfea."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -39,5 +39,11 @@ testpaths = ["tests"]
 pythonpath = ["src"]
 addopts = "-ra"
 
+[tool.ruff.lint]
+extend-select = ["RUF022"]
+
 [tool.setuptools.package-data]
-"morphopt.ui" = ["templates/*.morph", "templates/*.npz"]
+"morphopt.ui" = [
+    "locales/*.json",
+    "theme/styles/*.qss",
+]

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

@@ -71,17 +71,20 @@ from .opt_runner import debug_optimization, start_optimization
 from .optcore.controller import Controller
 from .optcore.history import History
 from .optcore.modelparams import (
-    BasePartInterface,
+    BaseModelComponent,
+    BasePart,
+    CADPart,
+    BoxPart,
     FEAParams,
     GeometryParams,
-    INPPartInterface,
+    INPPart,
     MaterialsParams,
     Params,
-    TorchFEAPartInterface,
+    TorchFEAPart,
     load_model_assembly,
     resolve_model_path,
 )
-from .optcore.modelparams.materialinterface import HomogeneousMaterial
+from .optcore.modelparams.materials import HomogeneousMaterial
 from .optcore.objfunc import ObjectiveFunction
 from .optcore.protocal import (
     ProtocalInitializable,
@@ -91,7 +94,15 @@ from .optcore.protocal import (
 )
 from .optcore.solver import Solver
 from .optcore.updaters import Updaters
-from .shapeopt import BoundaryPartInterface, UpdaterBoundaryPart
+from .shapeopt import (
+    BoundaryPart,
+    UpdaterBoundaryPart,
+    BaseSurfaceConstraints,
+    SurfaceRelationConstraint,
+    BspSurfaceRelationConstraint,
+    CPGEOSurfaceRelationConstraint,
+)
+from .codesign import OffsetBoundaryPart, UpdaterOffsetBoundaryPart
 from .simp import SIMP_BSPFieldMaterials, UpdaterSIMPMaterial
 
 # endregion

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-4.0.0 → 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 CodesignBoundaryPartInterface
+from .offset_boundary_part import OffsetBoundaryPart
 
 
 class InwardCurvatureRadius(BaseConstraints):
@@ -17,13 +18,13 @@ class InwardCurvatureRadius(BaseConstraints):
         self,
         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:
         """
@@ -71,7 +72,9 @@ class InwardCurvatureRadius(BaseConstraints):
 
     @staticmethod
     def _principal_curvatures(
-        rdu: torch.Tensor, rdu2: torch.Tensor, eps: float = 1e-12
+        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)
@@ -96,11 +99,11 @@ class InwardCurvatureRadius(BaseConstraints):
         """Take the Part this constraint is evaluated for.
 
         The geometry updater hands over the Part it evaluates; only a
-        :class:`~morphopt.codesign.CodesignBoundaryPartInterface` carries 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, CodesignBoundaryPartInterface):
+        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__})."
@@ -127,9 +130,15 @@ class InwardCurvatureRadius(BaseConstraints):
             if t <= 0:
                 continue
 
-            margin_abs = max(float((self.margin_ratio * t) + self.margin), 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, 1e-12)
+            barrier_thre = max(
+                k_limit * self.barrier_thre_ratio,
+                CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
+            )
 
             k1, k2 = self._principal_curvatures(rdu[i], rdu2[i])
 
@@ -146,7 +155,8 @@ class InwardCurvatureRadius(BaseConstraints):
                 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
+                        min=0.0,
+                        max=CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_EXPONENT_MAX,
                     )
                 )
                 penalty_strong = self.penalty_scale * penalty * hard_boost
@@ -168,16 +178,16 @@ class OffsetSurfaceMinThickness(BaseConstraints):
         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.
@@ -233,7 +243,10 @@ 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(
@@ -249,17 +262,17 @@ class OffsetSurfaceMinThickness(BaseConstraints):
             if self.min_distance is not None
             else (2.0 * thickness)
         )
-        return max(dmin, 1e-12)
+        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.CodesignBoundaryPartInterface` carries 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, CodesignBoundaryPartInterface):
+        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__})."
@@ -318,7 +331,8 @@ class OffsetSurfaceMinThickness(BaseConstraints):
             if thickness <= 0:
                 continue
             barrier_thre = max(
-                self._min_distance(thickness) * self.barrier_thre_ratio, 1e-12
+                self._min_distance(thickness) * self.barrier_thre_ratio,
+                CONSTANT.KERNEL.CODESIGN.GEOMETRY_TOLERANCE,
             )
 
             # Base surface normals (offset surface shares same normal direction)
@@ -343,7 +357,10 @@ class OffsetSurfaceMinThickness(BaseConstraints):
                 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(
@@ -361,7 +378,8 @@ class OffsetSurfaceMinThickness(BaseConstraints):
                 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
+                        min=0.0,
+                        max=CONSTANT.KERNEL.CODESIGN.HARD_VIOLATION_EXPONENT_MAX,
                     )
                 )
                 penalty_strong = self.penalty_scale * l * hard_boost * np_smooth

morphopt-4.0.0/src/morphopt/codesign/geometry.py → morphopt-4.0.1/src/morphopt/codesign/offset_boundary_part.py

@@ -1,4 +1,4 @@
-"""Co-design boundary part interface: cavity surfaces with an offset shell.
+"""Co-design boundary part: cavity surfaces with an offset shell.
 
 The co-design (``codesign``) scheme extends the shape-optimization boundary
 description with a solid shell: every cavity surface (index ``1..n``) is offset
@@ -13,12 +13,13 @@ import numpy as np
 import torch
 import torchfea
 
-from ..shapeopt.boundarypartinterface import BoundaryPartInterface
+from ..constants import CONSTANT
+from ..shapeopt.boundary_part import BoundaryPart
 
-__all__ = ["CodesignBoundaryPartInterface"]
+__all__ = ["OffsetBoundaryPart"]
 
 
-class CodesignBoundaryPartInterface(BoundaryPartInterface):
+class OffsetBoundaryPart(BoundaryPart):
     """Boundary-surface geometry whose cavity surfaces carry a solid shell.
 
     Parameters
@@ -31,7 +32,7 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
 
     def __init__(
         self,
-        shell_thickness: float = 1.0,
+        shell_thickness: float = CONSTANT.KERNEL.CODESIGN_GEOMETRY.DEFAULT_SHELL_THICKNESS,
         num_layers: int = 1,
         **kwargs: object,
     ) -> None:
@@ -40,17 +41,16 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
         self.shell_thickness: float = float(shell_thickness)
         """Total thickness of the offset shell on the cavity surfaces."""
 
-        self.num_layers: int = max(1, int(num_layers))
+        self.num_layers: int = int(num_layers)
         """Number of wedge layers through the shell thickness."""
 
         self._node_idx: list[np.ndarray] = []
         """Node indices of each offset layer (0 = base surface mesh)."""
 
-        self._tri_local: np.ndarray | None = None
-        """Cavity triangle connectivity stored with local node indices."""
-
-        self._shell_elem_offset: int | None = None
-        """Element-id offset of the shell block (0-based)."""
+        if self.shell_thickness <= 0:
+            raise ValueError("shell_thickness must be positive.")
+        if self.num_layers < 1:
+            raise ValueError("num_layers must be at least one.")
 
     # ------------------------------------------------------------- shell mesh
     def _compute_normals(self, base_nodes: torch.Tensor) -> torch.Tensor:
@@ -60,8 +60,9 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
             surface = self.surfaceinterfaces[index]
             normals.append(
                 surface.get_normals(
-                    torch.from_numpy(surface.surf_node_uv).to(
-                        torch.get_default_device()
+                    torch.as_tensor(
+                        surface.surf_node_uv, device=base_nodes.device,
+                        dtype=base_nodes.dtype,
                     )
                 )
             )
@@ -76,16 +77,19 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
         """Add the offset shell wedge elements to the meshed Part."""
         return self._build_shell_c3d6(part)
 
-    def _build_shell_c3d6(self, part: torchfea.Part) -> torchfea.Part:
-        thickness = float(self.shell_thickness)
-        if thickness <= 0 or self.num_layers <= 0:
-            return part
+    def build_part(self, path_result=None, pools=None) -> torchfea.Part:
+        """Build and validate the offset wedges, including quadratic conversion."""
+        part = super().build_part(path_result=path_result, pools=pools)
+        shell = part.elems["C3D6"]
+        shell.initialize(nodes=part.nodes)
+        weights = shell.gaussian_weight
+        if not torch.isfinite(weights).all() or (weights <= 0).any():
+            raise ValueError(f"Invalid offset shell mesh on Part {self.part_name!r}.")
+        return part
 
+    def _build_shell_c3d6(self, part: torchfea.Part) -> torchfea.Part:
         # Ensure surface elements exist so we can query triangle meshes.
-        try:
-            part.surfaces.initialize(part)
-        except Exception:
-            pass
+        part.surfaces.initialize(part)
 
         tri_by_surface: dict[int, np.ndarray] = {}
         tri_local_by_surface: dict[int, np.ndarray] = {}
@@ -100,7 +104,7 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
             cavity_order.append(sidx)
             tri_by_surface[sidx] = tri
             base_ids_blocks.append(
-                np.sort(np.asarray(part.set_nodes[surf_name], dtype=int))
+                np.asarray(self.surfaceinterfaces[sidx].surf_node_idx, dtype=int)
             )
 
         if len(tri_by_surface) == 0:
@@ -115,7 +119,6 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
         local_map = -np.ones((int(part.nodes.shape[0]),), dtype=int)
         local_map[base_ids] = np.arange(base_ids.shape[0], dtype=int)
 
-        tri_local_all = []
         for sidx in cavity_order:
             tri_global = tri_by_surface[sidx]
             tri_local = local_map[tri_global]
@@ -125,8 +128,6 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
                 )
             tri_local = tri_local.astype(int)
             tri_local_by_surface[sidx] = tri_local
-            tri_local_all.append(tri_local)
-        self._tri_local = np.concatenate(tri_local_all, axis=0).astype(int)
 
         device = part.nodes.device
         base_ids_t = torch.as_tensor(base_ids, dtype=torch.long, device=device)
@@ -155,7 +156,6 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
                 continue
             existing_max = max(existing_max, int(element._elems_index.max().item()))
         elem_offset = int(existing_max + 1)
-        self._shell_elem_offset = elem_offset
 
         # Build linear wedge connectivity (C3D6) for all layers.
         wedge6_blocks = []
@@ -217,10 +217,7 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
                 )
 
         # Refresh the surfaces cache to include the newly added offset surfaces.
-        try:
-            part.surfaces.initialize(part)
-        except Exception:
-            pass
+        part.surfaces.initialize(part)
 
         return part
 
@@ -231,9 +228,6 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
         """Update the Part nodes and keep the offset layers consistent."""
         super().modify_assembly(design_sensitivity_vars, assembly)
 
-        if len(self._node_idx) == 0 or self._tri_local is None:
-            return
-
         part = assembly.get_part(self.part_name)
         nodes = part.nodes.clone()
 
@@ -262,4 +256,8 @@ class CodesignBoundaryPartInterface(BoundaryPartInterface):
     @staticmethod
     def _default_opacity(index: int) -> float:
         """The solid volume is hidden so the shell stays visible."""
-        return 0.0 if index == 0 else 1.0
+        return (
+            0.0
+            if index == 0
+            else CONSTANT.KERNEL.VISUALIZATION.OFFSET_SHELL_SURFACE_OPACITY
+        )

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

@@ -0,0 +1,29 @@
+"""Geometry updates for one cavity offset Part."""
+
+from ..shapeopt.update_boundary_part import UpdaterBoundaryPart
+from ..shapeopt import objectivefuncs as shape_objectivefuncs
+from .offset_boundary_part import OffsetBoundaryPart
+from .constraints import InwardCurvatureRadius, OffsetSurfaceMinThickness
+
+
+class UpdaterOffsetBoundaryPart(UpdaterBoundaryPart):
+    """Reuse shape updates, binding only to an OffsetBoundaryPart.
+
+    Register with ``add_geometry_updater(self.Offset(), name="body")``.
+    Offset layer positions follow the Part's surface variables automatically.
+    """
+
+    target_type = OffsetBoundaryPart
+
+    class objectivefuncs:
+        """Shape objectives and constraints for cavity offset geometry."""
+
+        ShapeDerivative = shape_objectivefuncs.ShapeDerivative
+        Fairness = shape_objectivefuncs.Fairness
+        Distance = shape_objectivefuncs.Distance
+        VolumeMaximization = shape_objectivefuncs.VolumeMaximization
+        boundarys = shape_objectivefuncs.boundarys
+        BaseObjective = shape_objectivefuncs.BaseObjective
+        BaseConstraints = shape_objectivefuncs.BaseConstraints
+        InwardCurvatureRadius = InwardCurvatureRadius
+        OffsetSurfaceMinThickness = OffsetSurfaceMinThickness