morphopt 3.2.1__tar.gz → 4.0.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: morphopt
-Version: 3.2.1
-Summary: A morphing optimization framework using PyTorch and Abaqus.
+Version: 4.0.0
+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
 

{morphopt-3.2.1 → morphopt-4.0.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "morphopt"
-version = "3.2.1"
-description = "A morphing optimization framework using PyTorch and Abaqus."
+version = "4.0.0"
+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,17 @@ 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.setuptools.package-data]
+"morphopt.ui" = ["templates/*.morph", "templates/*.npz"]

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

@@ -2,10 +2,18 @@
 A differentiable structural optimization framework that eliminates manual sensitivity derivation by fusing the adjoint method with automatic differentiation (AD). The sensitivity corresponds to the virtual work of residual force derivatives on the adjoint displacement field, computed via a single backpropagation through the residual graph. MorphOpt provides a unified interface for geometry, load, and material definition, calls torchfea for GPU-accelerated differentiable nonlinear FEA and adjoint-AD sensitivity, and employs a trust-region optimizer with L-BFGS for design updates. Validated on SIMP topology optimization with B-spline density fields and pneumatic soft robot shape optimization with deformation-dependent follower loads.
 """
 
+# Torch and TorchFEA use GNU OpenMP in this environment.  Set MKL's matching
+# threading layer before importing any module that can load NumPy or Torch.
+import os as __os
+import sys as __sys
+
+if __sys.platform.startswith("linux"):
+    __os.environ["MKL_THREADING_LAYER"] = "GNU"
 
 # 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.
@@ -18,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
@@ -26,56 +34,70 @@ 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.modelparams import FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry, HomogeneousMaterial, Params
+from .optcore.history import History
+from .optcore.modelparams import (
+    BasePartInterface,
+    FEAParams,
+    GeometryParams,
+    INPPartInterface,
+    MaterialsParams,
+    Params,
+    TorchFEAPartInterface,
+    load_model_assembly,
+    resolve_model_path,
+)
+from .optcore.modelparams.materialinterface 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 BoundaryPartInterface, UpdaterBoundaryPart
+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.0/src/morphopt/codesign/__init__.py

@@ -0,0 +1,23 @@
+"""Co-design (codesign) scheme: shape optimization coupled with SIMP materials."""
+
+from ..optcore import MaterialsParams, ObjectiveFunction, Solver, Updaters
+from ..shapeopt import UpdaterBoundaryPart
+from ..simp import SIMP_BSPFieldMaterials, UpdaterSIMPMaterial
+from .constraints import InwardCurvatureRadius, OffsetSurfaceMinThickness
+from .feaparams import CodesignFEAParams
+from .geometry import CodesignBoundaryPartInterface
+from .geometryparams import GeometryParams
+from .params import Params
+
+
+def plot_geometry_and_materials(geometry: GeometryParams, materials: MaterialsParams):
+    """Plot every geometry interface together with the material fields."""
+    import pyvista as pv
+
+    plotter = pv.Plotter(window_size=(1400, 900))
+    plotter.set_background("white")
+
+    plotter = materials.plot(plotter=plotter)
+    geometry.plot(plotter=plotter)
+
+    plotter.show()

{morphopt-3.2.1 → morphopt-4.0.0}/src/morphopt/codesign/constraints.py

@@ -1,7 +1,7 @@
 import torch
 
 from ..shapeopt.objectivefuncs.basefuncs import BaseConstraints
-from .geometry import CodesignGeometry
+from .geometry import CodesignBoundaryPartInterface
 
 
 class InwardCurvatureRadius(BaseConstraints):
@@ -15,7 +15,6 @@ class InwardCurvatureRadius(BaseConstraints):
 
     def __init__(
         self,
-        geometry: CodesignGeometry,
         surface_start: int = 1,
         surface_ids: list[int] | None = None,
         margin: float = 0.4,
@@ -31,7 +30,6 @@ class InwardCurvatureRadius(BaseConstraints):
         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,27 +40,39 @@ 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
         self.surface_start = int(surface_start)
-        self.surface_ids = None if surface_ids is None else [int(i) for i in surface_ids]
+        """Stores the surface start used by InwardCurvatureRadius."""
+        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
+        """Stores the margin used by InwardCurvatureRadius."""
         self.margin_ratio = float(margin_ratio)
+        """Stores the margin ratio used by InwardCurvatureRadius."""
         self.barrier_thre_ratio = float(barrier_thre_ratio)
+        """Stores the barrier thre ratio used by InwardCurvatureRadius."""
         self.barrier_ratio = float(barrier_ratio)
+        """Stores the barrier ratio used by InwardCurvatureRadius."""
         self.p = int(p)
+        """Stores the p used by InwardCurvatureRadius."""
         self.penalty_scale = float(penalty_scale)
+        """Stores the penalty scale used by InwardCurvatureRadius."""
         self.hard_violation_beta = float(hard_violation_beta)
+        """Stores the hard violation beta used by InwardCurvatureRadius."""
         self.normal_sign = 1.0 if normal_sign >= 0 else -1.0
+        """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 = 1e-12
+    ) -> tuple[torch.Tensor, torch.Tensor]:
         normal0 = torch.cross(rdu[:, :, 1], rdu[:, :, 0], dim=1)
         normal = normal0 / (normal0.norm(dim=1, keepdim=True) + eps)
 
@@ -82,26 +92,45 @@ 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.CodesignBoundaryPartInterface` carries a
+        shell, so anything else is rejected here.
+        """
+        super().initialize(r0=r0, rdu0=rdu0, *args, **kwargs)
+        if not isinstance(part_interface, CodesignBoundaryPartInterface):
+            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), 1e-12)
+            k_limit = 1.0 / (t + margin_abs)
+            barrier_thre = max(k_limit * self.barrier_thre_ratio, 1e-12)
 
-        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)
@@ -109,11 +138,17 @@ 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=20.0
+                    )
+                )
                 penalty_strong = self.penalty_scale * penalty * hard_boost
                 loss = loss + (self.scaler[i][index] * penalty_strong).sum()
 
@@ -130,7 +165,6 @@ class OffsetSurfaceMinThickness(BaseConstraints):
 
     def __init__(
         self,
-        geometry: CodesignGeometry,
         surface_start: int = 1,
         surface_ids: list[int] | None = None,
         min_distance: float | None = None,
@@ -145,26 +179,51 @@ class OffsetSurfaceMinThickness(BaseConstraints):
         normal_min: float = -0.7,
         normal_max: float = -0.5,
     ) -> 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
         self.surface_start = int(surface_start)
-        self.surface_ids = None if surface_ids is None else [int(i) for i in surface_ids]
+        """Stores the surface start used by OffsetSurfaceMinThickness."""
+        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
+        """Stores the min distance used by OffsetSurfaceMinThickness."""
         self.search_ratio = float(search_ratio)
+        """Stores the search ratio used by OffsetSurfaceMinThickness."""
         self.barrier_thre_ratio = float(barrier_thre_ratio)
+        """Stores the barrier thre ratio used by OffsetSurfaceMinThickness."""
         self.barrier_ratio = float(barrier_ratio)
+        """Stores the barrier ratio used by OffsetSurfaceMinThickness."""
         self.p = int(p)
+        """Stores the p used by OffsetSurfaceMinThickness."""
         self.penalty_scale = float(penalty_scale)
+        """Stores the penalty scale used by OffsetSurfaceMinThickness."""
         self.hard_violation_beta = float(hard_violation_beta)
+        """Stores the hard violation beta used by OffsetSurfaceMinThickness."""
         self.normal_sign = 1.0 if normal_sign >= 0 else -1.0
+        """Stores the normal sign used by OffsetSurfaceMinThickness."""
         self.normal_opposition_thre = float(normal_opposition_thre)
+        """Stores the normal opposition thre used by OffsetSurfaceMinThickness."""
         self.normal_min = float(normal_min)
+        """Stores the normal min used by OffsetSurfaceMinThickness."""
         self.normal_max = float(normal_max)
+        """Stores the normal max used by OffsetSurfaceMinThickness."""
 
         self._neighbor_pairs: dict[int, torch.Tensor] = {}
+        """Stores the neighbor pairs used by OffsetSurfaceMinThickness."""
         self._neighbor_mindist: dict[int, torch.Tensor] = {}
+        """Stores the neighbor mindist used by OffsetSurfaceMinThickness."""
 
     def _selected_surface_ids(self, n_surface: int) -> list[int]:
         if self.surface_ids is None:
@@ -177,33 +236,60 @@ class OffsetSurfaceMinThickness(BaseConstraints):
         normals = normal0 / (normal0.norm(dim=1, keepdim=True) + 1e-12)
         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, 1e-12)
+
+    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
+        shell, so anything else is rejected here.
+        """
         super().initialize(r0=r0, rdu0=rdu0, *args, **kwargs)
+        if not isinstance(part_interface, CodesignBoundaryPartInterface):
+            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)
@@ -213,22 +299,28 @@ 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, 1e-12
+            )
+
             # 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)
@@ -241,28 +333,42 @@ 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)
 
             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=20.0
+                    )
+                )
                 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
-

morphopt-4.0.0/src/morphopt/codesign/feaparams.py

@@ -0,0 +1,66 @@
+"""FEA parameter handling for the co-design (``codesign``) scheme.
+
+Co-design builds extra ``C3D6``/``C3D15`` shell elements on the cavity surfaces
+of every shell-carrying geometry interface.  Those elements need to be
+initialized (integration points and weights) against their Part before the
+analysis runs, which is what this specialization of ``FEAParams`` does.
+"""
+
+import torchfea
+
+import morphopt
+
+from ..optcore.modelparams.feaparams import FEAParams
+from ..optcore.modelparams.geometry import GeometryParams
+from .geometry import CodesignBoundaryPartInterface
+
+__all__ = ["CodesignFEAParams"]
+
+
+class CodesignFEAParams(FEAParams):
+    """FEA parameters that initialize the co-design offset shells."""
+
+    def shell_interfaces(
+        self, geometry: GeometryParams | None = None
+    ) -> list[CodesignBoundaryPartInterface]:
+        """Geometry interfaces carrying an offset shell."""
+        if geometry is None:
+            controller = morphopt.controller
+            geometry = controller.params.geometry if controller is not None else None
+        if geometry is None:
+            return []
+        return [
+            interface
+            for interface in geometry.interfaces.values()
+            if isinstance(interface, CodesignBoundaryPartInterface)
+        ]
+
+    def create_fea(self, assembly: torchfea.Assembly) -> torchfea.FEAController:
+        """Create the FEA controller and initialize every offset shell."""
+        fe = super().create_fea(assembly=assembly)
+
+        for interface in self.shell_interfaces():
+            if float(interface.shell_thickness) <= 0:
+                continue
+
+            part = fe.assembly.get_part(interface.part_name)
+            element_shell = None
+            for name in ("C3D6", "C3D15"):
+                if name in part.elems:
+                    element_shell = part.elems[name]
+                    break
+            if element_shell is None:
+                raise KeyError(
+                    f"Shell wedge elements not found on Part "
+                    f"{interface.part_name!r} (expected 'C3D6' or 'C3D15')."
+                )
+
+            element_shell.initialize(nodes=part.nodes)
+            if element_shell.gaussian_weight.min() < 0:
+                raise ValueError(
+                    f"The Gaussian weights of the shell elements on Part "
+                    f"{interface.part_name!r} are negative. Check the mesh "
+                    "quality of the offset shell."
+                )
+
+        return fe