morphopt 3.2.1__tar.gz → 3.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphopt
-Version: 3.2.1
+Version: 3.2.2
 Summary: A morphing optimization framework using PyTorch and Abaqus.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

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

@@ -1,6 +1,6 @@
 [project]
 name = "morphopt"
-version = "3.2.1"
+version = "3.2.2"
 description = "A morphing optimization framework using PyTorch and Abaqus."
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -2,6 +2,13 @@
 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
@@ -57,7 +64,10 @@ def enable_logging(level=__logging.INFO, log_file=None, file_log_level=__logging
 
 # region optcore imports
 from .optcore.controller import Controller
-from .optcore.modelparams import FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry, HomogeneousMaterial, Params
+from .optcore.modelparams import (
+    FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry,
+    MaterialsParams, Params,
+)
 from .optcore.solver import Solver
 from .optcore.modelparams import Params
 from .optcore.updaters import Updaters

{morphopt-3.2.1 → morphopt-3.2.2}/src/morphopt/codesign/__init__.py

@@ -1,13 +1,15 @@
-from .material import CodesignMaterials
 from .geometry import CodesignGeometry
 from .constraints import InwardCurvatureRadius, OffsetSurfaceMinThickness
 from .feaparams import CodesignFEAParams
 from .params import Params
-from ..optcore import Solver, Updaters
+from ..optcore import (
+    MaterialsParams, Solver, Updaters,
+)
 from ..shapeopt import GeometryParams, UpdaterGeometries, ObjectiveFunction
 from ..simp import UpdaterMaterials
+from ..simp import SIMP_BSPFieldMaterials
 
-def plot_geometry_and_materials(geometry: CodesignGeometry, materials: CodesignMaterials):
+def plot_geometry_and_materials(geometry: CodesignGeometry, materials: MaterialsParams):
     import pyvista as pv
     plotter = pv.Plotter(window_size=(1400, 900))
     plotter.set_background('white')
@@ -15,4 +17,4 @@ def plot_geometry_and_materials(geometry: CodesignGeometry, materials: CodesignM
     plotter = materials.plot(plotter=plotter)
     geometry.plot(plotter=plotter, opacity=[0.0, 1.0])
 
-    plotter.show()
+    plotter.show()

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

@@ -49,17 +49,28 @@ class InwardCurvatureRadius(BaseConstraints):
         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]
+        """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]:
@@ -119,7 +130,6 @@ class InwardCurvatureRadius(BaseConstraints):
 
         return loss
 
-
 class OffsetSurfaceMinThickness(BaseConstraints):
     """
     Enforce a minimum distance on the offset surface to reduce self-intersection risk.
@@ -148,23 +158,39 @@ class OffsetSurfaceMinThickness(BaseConstraints):
         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]
+        """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:
@@ -265,4 +291,3 @@ class OffsetSurfaceMinThickness(BaseConstraints):
                 loss = loss + (penalty_strong * scaler_n0[indexl] * scaler_n1[indexl]).sum()
 
         return loss
-

{morphopt-3.2.1 → morphopt-3.2.2}/src/morphopt/codesign/feaparams.py

@@ -4,6 +4,7 @@ import torch
 import numpy as np
 
 import torchfea
+import morphopt
 from .. import FEAParams
 import bspmap
 
@@ -15,7 +16,11 @@ class CodesignFEAParams(FEAParams):
 
     def create_fea(self, assembly: torchfea.Assembly) -> torchfea.FEAController:
         fe = super().create_fea(assembly=assembly)
-        fe_part = fe.assembly.get_part('final_model')
+        geometry = getattr(getattr(morphopt, "controller", None), "params", None)
+        geometry = getattr(geometry, "geometry", None)
+        part_name = getattr(geometry, "part_name", "final_model")
+        instance_name = getattr(geometry, "instance_name", "final_model")
+        fe_part = fe.assembly.get_part(part_name)
 
         if 'C3D6' in fe_part.elems:
             element_shell = fe_part.elems['C3D6']
@@ -40,10 +45,10 @@ class CodesignFEAParams(FEAParams):
             )
             surfcenter = surfnodes.mean(dim=1)
 
-            fe.assembly.get_instance('final_model').exterior_surface = 'surface_1_offset'
+            fe.assembly.get_instance(instance_name).exterior_surface = 'surface_1_offset'
 
-            mesh_1all = fe.assembly.get_instance('final_model').get_mesh(surf_name='surface_1_All')
-            mesh_1offset = fe.assembly.get_instance('final_model').get_mesh(surf_name='surface_1_offset')
+            mesh_1all = fe.assembly.get_instance(instance_name).get_mesh(surf_name='surface_1_All')
+            mesh_1offset = fe.assembly.get_instance(instance_name).get_mesh(surf_name='surface_1_offset')
 
             import morphopt
             normal_cpgeo = morphopt.controller.params.geometry.surface_list[1].get_normals(torch.from_numpy(morphopt.controller.params.geometry.surface_list[1].surf_node_uv).to(torch.get_default_device()))

{morphopt-3.2.1 → morphopt-3.2.2}/src/morphopt/codesign/geometry.py

@@ -6,10 +6,6 @@ import torchfea
 
 class CodesignGeometry(GeometryParams):
 
-
-    
-
-
     def __init__(self, 
                  fea_seed_size: float,
                  mesh_order: int = 1,
@@ -50,12 +46,19 @@ class CodesignGeometry(GeometryParams):
         """Element-id offset for the shell block (0-based)."""
 
         self._reinit_opt_steps: int = 100
+        """Stores the reinit opt steps used by CodesignGeometry."""
         self._reinit_opt_lr: float = 5e-3
+        """Stores the reinit opt lr used by CodesignGeometry."""
         self._reinit_opt_curvature_weight: float = 1e2
+        """Stores the reinit opt curvature weight used by CodesignGeometry."""
         self._reinit_opt_shape_weight: float = 1e2
+        """Stores the reinit opt shape weight used by CodesignGeometry."""
         self._reinit_opt_curvature_margin_ratio: float = 0.25
+        """Stores the reinit opt curvature margin ratio used by CodesignGeometry."""
         self._reinit_opt_inward_sign: float = 1.0
+        """Stores the reinit opt inward sign used by CodesignGeometry."""
         self._reinit_opt_accept_only_improve: bool = True
+        """Stores the reinit opt accept only improve used by CodesignGeometry."""
 
     # def reinitialize(self, iteration):
     #     super().reinitialize(iteration)
@@ -334,7 +337,7 @@ class CodesignGeometry(GeometryParams):
         if len(self._node_idx) == 0 or self._tri_local is None:
             return
         
-        part = assembly.get_part('final_model')
+        part = assembly.get_part(self.part_name)
 
         nodes = part.nodes.clone()
         base_ids_t = torch.as_tensor(self._node_idx[0], dtype=torch.long, device=nodes.device)
@@ -356,4 +359,4 @@ class CodesignGeometry(GeometryParams):
 
     def plot(self, plotter=None, opacity = None, meshes=None):
         opacity = [0.0 if i == 0 else 1.0 for i in range(self.num_surface)]
-        return super().plot(plotter, opacity, meshes)
+        return super().plot(plotter, opacity, meshes)

morphopt-3.2.2/src/morphopt/optcore/__init__.py

@@ -0,0 +1,8 @@
+from .modelparams import (
+    Params, BaseGeometry, FEAParams,
+    MaterialsParams, BaseParams,
+    FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry,
+)
+from .updaters import BaseUpdater, Updaters
+from .solver import Solver
+from .objfunc import ObjectiveFunction

{morphopt-3.2.1 → morphopt-3.2.2}/src/morphopt/optcore/modelparams/__init__.py

@@ -1,5 +1,5 @@
 from .geometry import FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry, BaseGeometry
 from .feaparams import FEAParams
-from .materials import HomogeneousMaterial, BaseMaterials
+from .materials import MaterialsParams
 from .params import Params
 from .baseparam import BaseParams

morphopt-3.2.2/src/morphopt/optcore/modelparams/materialinterface/__init__.py

@@ -0,0 +1,11 @@
+"""Material assignment interfaces."""
+
+from .basematerialinterface import BaseMaterialInterface
+from .homogeneousmaterial import HomogeneousMaterial
+from .materialmodels import MaterialModels
+
+__all__ = [
+    "BaseMaterialInterface",
+    "HomogeneousMaterial",
+    "MaterialModels",
+]

morphopt-3.2.2/src/morphopt/optcore/modelparams/materialinterface/basematerialinterface.py

@@ -0,0 +1,69 @@
+"""Base class for material assignments to TorchFEA parts."""
+
+from __future__ import annotations
+
+import torch
+import torchfea
+
+from ..baseparam import BaseParams
+from .materialmodels import MaterialModels
+
+
+class BaseMaterialInterface(BaseParams):
+    """Assign one material definition to elements in one Part.
+
+    ``elementname`` may be empty. In that case the interface is applied to
+    every element family in ``part_name``.
+    """
+
+    from .materialmodels import MaterialModels as materialmodels
+
+    def __init__(
+            self,
+            part_name: str,
+            material_parameters: MaterialModels.MaterialParameters,
+            elementname: str = "",
+            density: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.part_name = str(part_name or "").strip()
+        if not self.part_name:
+            raise ValueError("part_name cannot be empty.")
+        self.elementname = str(elementname or "").strip()
+        self.material_parameters: MaterialModels.MaterialParameters = material_parameters
+        self._density: float = float(density)
+        self._name: str = ""
+
+    @property
+    def density(self) -> float:
+        """Return the mass density assigned to the target elements."""
+        return self._density
+
+    @density.setter
+    def density(self, value: float) -> None:
+        """Set the mass density assigned to the target elements."""
+        self._density = float(value)
+
+    def target_elements(
+            self,
+            assembly: torchfea.Assembly,
+    ) -> list[tuple[str, torchfea.elements.Element_3D]]:
+        """Return the selected element families from the target Part."""
+        part = assembly.get_part(self.part_name)
+        if self.elementname:
+            if self.elementname not in part.elems:
+                raise KeyError(
+                    f"Element {self.elementname!r} does not exist on Part "
+                    f"{self.part_name!r}.")
+            return [(self.elementname, part.elems[self.elementname])]
+        if not part.elems:
+            raise ValueError(f"Part {self.part_name!r} contains no elements.")
+        return list(part.elems.items())
+
+    def set_materials(self, fe: torchfea.FEAController) -> None:
+        """Assign this interface to its target elements."""
+        raise NotImplementedError
+
+    def get_design_values(self) -> torch.Tensor:
+        """Return live design values for a designable material interface."""
+        return torch.zeros(0)

morphopt-3.2.2/src/morphopt/optcore/modelparams/materialinterface/homogeneousmaterial.py

@@ -0,0 +1,21 @@
+"""Uniform material assignment interface."""
+
+from __future__ import annotations
+
+import torchfea
+
+from .basematerialinterface import BaseMaterialInterface
+from .materialmodels import MaterialModels
+
+
+class HomogeneousMaterial(BaseMaterialInterface):
+    """Assign one uniform TorchFEA material to a Part."""
+
+    def set_materials(self, fe: torchfea.FEAController) -> None:
+        """Assign the uniform material and density to target elements."""
+        for _name, elements in self.target_elements(fe.assembly):
+            elements.delete_material()
+            elements.set_materials(MaterialModels.create_material(
+                material_parameters=self.material_parameters,
+            ))
+            elements.density = self.density

morphopt-3.2.2/src/morphopt/optcore/modelparams/materialinterface/materialmodels.py

@@ -0,0 +1,111 @@
+"""TorchFEA material models exposed by :class:`MaterialsParams`."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import ClassVar
+
+import torchfea
+
+
+class MaterialModels:
+    """Material parameter types and their TorchFEA material classes."""
+
+    @dataclass(frozen=True)
+    class MaterialParameters:
+        """Base type for all material parameter objects."""
+
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]]
+
+    @dataclass(frozen=True)
+    class LinearElasticParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.LinearElastic``."""
+
+        E: float
+        nu: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.LinearElastic
+
+    @dataclass(frozen=True)
+    class NeoHookeanParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.NeoHookean``."""
+
+        mu: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.NeoHookean
+
+    @dataclass(frozen=True)
+    class NeoHookeanLnJParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.NeoHookeanLnJ``."""
+
+        mu: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.NeoHookeanLnJ
+
+    @dataclass(frozen=True)
+    class MooneyRivlinParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.MooneyRivlin``."""
+
+        c10: float
+        c01: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.MooneyRivlin
+
+    @dataclass(frozen=True)
+    class YeohParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.Yeoh``."""
+
+        c1: float
+        c2: float
+        c3: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.Yeoh
+
+    @dataclass(frozen=True)
+    class GentParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.Gent``."""
+
+        mu: float
+        Jm: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.Gent
+
+    @dataclass(frozen=True)
+    class ArrudaBoyceParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.ArrudaBoyce``."""
+
+        mu: float
+        N: float
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.ArrudaBoyce
+
+    @dataclass(frozen=True)
+    class OgdenParams(MaterialParameters):
+        """Parameters for ``torchfea.materials.Ogden``."""
+
+        mu: float
+        alpha: float | list[float]
+        kappa: float
+        material_class: ClassVar[type[torchfea.materials.Materials_Base]] = \
+            torchfea.materials.Ogden
+
+    @classmethod
+    def create_material(
+            cls,
+            material_parameters: MaterialParameters,
+    ) -> torchfea.materials.Materials_Base:
+        """Create a TorchFEA material from its typed parameter object."""
+        if not isinstance(material_parameters, cls.MaterialParameters):
+            raise TypeError(
+                "material_parameters must be a MaterialModels parameter object.")
+        parameters = {
+            field.name: getattr(material_parameters, field.name)
+            for field in fields(material_parameters)
+        }
+        return material_parameters.material_class(**parameters)