morphopt 3.2.2__tar.gz → 4.0.0__tar.gz

{morphopt-3.2.2 → morphopt-4.0.0}/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.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.2 → morphopt-4.0.0}/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.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.2 → morphopt-4.0.0}/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,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.history import History
 from .optcore.modelparams import (
-    FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry,
-    MaterialsParams, Params,
+    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.2 → 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,17 +40,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 +70,9 @@ 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 = 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)
 
@@ -93,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)
@@ -120,16 +138,23 @@ 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()
 
         return loss
 
+
 class OffsetSurfaceMinThickness(BaseConstraints):
     """
     Enforce a minimum distance on the offset surface to reduce self-intersection risk.
@@ -140,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,
@@ -155,13 +179,22 @@ 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
-        """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
@@ -203,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)
@@ -239,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)
@@ -267,27 +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