morphopt 3.2.0__tar.gz → 3.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphopt
-Version: 3.2.0
+Version: 3.2.1
 Summary: A morphing optimization framework using PyTorch and Abaqus.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -16,7 +16,7 @@ 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.0
+Requires-Dist: torchfea>=1.1.1
 Requires-Dist: trimesh>=4.11.5
 Requires-Dist: networkx>=3.6.1
 Requires-Dist: scipy>=1.17.1

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

@@ -1,6 +1,6 @@
 [project]
 name = "morphopt"
-version = "3.2.0"
+version = "3.2.1"
 description = "A morphing optimization framework using PyTorch and Abaqus."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -17,7 +17,7 @@ dependencies = [
     "tabulate>=0.9.0",
     "imageio>=2.37.3",
     "bspmap>=1.0.3",
-    "torchfea>=1.1.0",
+    "torchfea>=1.1.1",
     "trimesh>=4.11.5",
     "networkx>=3.6.1",
     "scipy>=1.17.1",

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

@@ -57,7 +57,7 @@ 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, FixedGeometry, HomogeneousMaterial, Params
+from .optcore.modelparams import FEAParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry, HomogeneousMaterial, Params
 from .optcore.solver import Solver
 from .optcore.modelparams import Params
 from .optcore.updaters import Updaters
@@ -79,4 +79,3 @@ from .utils import check_gradients, get_controller
 # endregion
 
 controller: Controller = None
-

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

@@ -1,4 +1,4 @@
-from .modelparams import Params, BaseGeometry, FEAParams, HomogeneousMaterial, BaseParams, FixedGeometryINP, FixedGeometry
+from .modelparams import Params, BaseGeometry, FEAParams, HomogeneousMaterial, BaseParams, FixedGeometryINP, FixedGeometryTorchFEA, FixedGeometry
 from .updaters import BaseUpdater, Updaters
 from .solver import Solver
-from .objfunc import ObjectiveFunction
+from .objfunc import ObjectiveFunction

{morphopt-3.2.0 → morphopt-3.2.1}/src/morphopt/optcore/controller.py

@@ -323,8 +323,22 @@ class Controller:
         self.history.append('objective', loss.item())
         self.history.append('metrics', self.objfun.get_metrics())
         self.history.append('time', [t1-t0, t2-t1, t3-t2, t4-t3])
-        self.history.append('num_elements', sum([elem._elems.shape[0] for elem in self.objfun.fe.assembly.get_instance('final_model').elems.values()]))
-        self.history.append('num_nodes', self.objfun.fe.assembly.get_instance('final_model').nodes.shape[0])
+        # Shape/codesign jobs historically used one ``final_model`` instance,
+        # while a SIMP job may import an Assembly from torchfea-ui with
+        # arbitrary Part/Instance names (for example ``Part-1-1``).  Record
+        # statistics from the actual Assembly instead of assuming a name.
+        instances = self.objfun.fe.assembly._instances.values()
+        num_elements = sum(
+            element._elems.shape[0]
+            for instance in instances
+            for element in instance.elems.values()
+        )
+        num_nodes = sum(
+            instance.nodes.shape[0]
+            for instance in self.objfun.fe.assembly._instances.values()
+        )
+        self.history.append('num_elements', num_elements)
+        self.history.append('num_nodes', num_nodes)
 
     def print_info(self, t0, t1, t2, t3, t4) -> None:
         """

morphopt-3.2.1/src/morphopt/optcore/modelparams/__init__.py

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

morphopt-3.2.1/src/morphopt/optcore/modelparams/geometry.py

@@ -0,0 +1,251 @@
+"""Geometry parameter classes and the TorchFEA Assembly import helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+import torchfea
+
+from .baseparam import BaseParams
+
+
+# ---------------------------------------------------------------------------
+# TorchFEA model import helpers
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class PartSummary:
+    name: str
+    node_sets: tuple[str, ...]
+    element_sets: tuple[str, ...]
+    surface_sets: tuple[str, ...]
+    element_types: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class InstanceSummary:
+    name: str
+    part_name: str
+
+
+@dataclass(frozen=True)
+class TorchFEAModelSummary:
+    path: str
+    parts: tuple[PartSummary, ...]
+    instances: tuple[InstanceSummary, ...]
+
+    def part_for_instance(self, instance_name: str) -> PartSummary | None:
+        instance = next(
+            (item for item in self.instances if item.name == instance_name), None)
+        if instance is None:
+            return None
+        return next(
+            (item for item in self.parts if item.name == instance.part_name), None)
+
+
+def resolve_model_path(model_directory: str, model_filename: str = "") -> Path:
+    """Resolve one exported TorchFEA ``.npz`` inside ``model_directory``."""
+    directory = Path(model_directory).expanduser().resolve()
+    if not directory.is_dir():
+        raise FileNotFoundError(
+            f"TorchFEA model directory does not exist: {directory}")
+
+    if model_filename:
+        candidate = Path(model_filename)
+        path = candidate if candidate.is_absolute() else directory / candidate
+        path = path.expanduser().resolve()
+        if not path.is_file():
+            raise FileNotFoundError(f"TorchFEA model file does not exist: {path}")
+        return path
+
+    candidates = sorted(
+        directory.glob("*.npz"), key=lambda item: item.stat().st_mtime_ns,
+        reverse=True)
+    if not candidates:
+        raise FileNotFoundError(
+            f"No TorchFEA .npz model was found in: {directory}")
+    return candidates[0].resolve()
+
+
+def inspect_model(model_directory: str,
+                  model_filename: str = "") -> TorchFEAModelSummary:
+    """Return selectable Part/Instance/set names from an exported model."""
+    path = resolve_model_path(model_directory, model_filename)
+    return _inspect_model_cached(str(path), path.stat().st_mtime_ns)
+
+
+@lru_cache(maxsize=16)
+def _inspect_model_cached(path: str, _mtime_ns: int) -> TorchFEAModelSummary:
+    controller = _read_controller(path)
+    source = controller.assembly
+    if source is None:
+        raise ValueError("The TorchFEA model does not contain an Assembly.")
+
+    parts = tuple(
+        PartSummary(
+            name=name,
+            node_sets=tuple(part.set_nodes.keys()),
+            element_sets=tuple(part.set_elements.keys()),
+            surface_sets=tuple(part.surfaces.keys()),
+            element_types=tuple(part.elems.keys()),
+        )
+        for name, part in source._parts.items()
+    )
+    instances = tuple(
+        InstanceSummary(name=name, part_name=instance.part_name)
+        for name, instance in source._instances.items()
+    )
+    if not parts:
+        raise ValueError("The TorchFEA Assembly contains no Parts.")
+    if not instances:
+        raise ValueError("The TorchFEA Assembly contains no Instances.")
+    return TorchFEAModelSummary(str(Path(path).resolve()), parts, instances)
+
+
+def load_geometry_assembly(model_directory: str,
+                           model_filename: str = "") -> torchfea.Assembly:
+    """Load a clean Assembly containing only cloned Parts and Instances."""
+    path = resolve_model_path(model_directory, model_filename)
+    controller = _read_controller(str(path))
+    source = controller.assembly
+    if source is None:
+        raise ValueError("The TorchFEA model does not contain an Assembly.")
+
+    assembly = torchfea.Assembly()
+    for name, part in source._parts.items():
+        cloned_part = torchfea.Serializable._deserialize(part._serialize())
+        if (cloned_part.exterior_surface == "extern"
+                and "extern" not in cloned_part.surfaces):
+            boundary = []
+            for element in cloned_part.elems.values():
+                boundary.extend(element.extract_boundary_surface_set())
+            if boundary:
+                cloned_part.surfaces["extern"] = boundary
+        assembly.add_part(cloned_part, name=name)
+    for name, instance in source._instances.items():
+        cloned_instance = torchfea.Serializable._deserialize(instance._serialize())
+        assembly.add_instance(cloned_instance, name=name)
+
+    if not assembly._parts:
+        raise ValueError("The TorchFEA Assembly contains no Parts.")
+    if not assembly._instances:
+        raise ValueError("The TorchFEA Assembly contains no Instances.")
+    return assembly
+
+
+def _read_controller(path: str) -> torchfea.FEAController:
+    """Deserialize a controller without initializing its analysis objects."""
+    with np.load(path, allow_pickle=True) as loaded:
+        if "data" not in loaded:
+            raise ValueError("The .npz file is not a TorchFEA model archive.")
+        return torchfea.FEAController._deserialize(loaded["data"])
+
+class BaseGeometry(BaseParams):
+    """
+    Base class for geometry parameter classes.
+
+    Subclasses must provide the mesh/geometry generation and assembly modification
+    behavior used by the optimization pipeline.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(**kwargs)
+
+    def generate(self, path_result: str, pools=None) -> torchfea.Assembly:
+        """Generate the FEA part for the current geometry."""
+        raise NotImplementedError
+    
+
+
+class FixedGeometry(BaseGeometry):
+    """
+    Base class for geometry whose FE assembly stays fixed during optimization.
+
+    Subclasses may read an INP mesh or a saved TorchFEA model.  In both cases
+    the assembly is built once and reused across optimization iterations.
+    """
+    def __init__(self):
+        super().__init__()
+        self._assembly: torchfea.Assembly = None
+        """
+        The FEA assembly containing the geometry for the optimization problem. This assembly is generated from a fixed mesh and does not change during optimization iterations.
+        """
+
+    @property
+    def assembly(self) -> torchfea.Assembly:
+        """
+        Get the FEA assembly containing the geometry for the optimization problem.
+
+        Returns:
+            torchfea.Assembly: The FEA assembly containing the geometry.
+        """
+        if self._assembly is None:
+            self._assembly = self.define_assembly()
+        return self._assembly
+
+    def define_assembly(self)-> torchfea.Assembly:
+        """
+        Define the assembly for the geometry using node and element data.
+
+        This method should be implemented in subclasses to create the assembly based on specific node and element data.
+
+        Returns:
+            torchfea.Assembly: The defined assembly for the geometry.
+        """
+        raise NotImplementedError
+
+    def generate(self, *args, **kwargs):
+        """Return the lazily built fixed torchfea assembly."""
+        return self.assembly
+
+class FixedGeometryINP(FixedGeometry):
+    """
+    Geometry parameters class for fixed mesh geometry using an Abaqus .inp file.
+    """
+    def __init__(self, mesh_file: str, part_name: str = 'final_model'):
+        super().__init__()
+        self._mesh_file = mesh_file
+        """
+        The file path of the mesh to be loaded for the geometry.
+        """
+
+        self._part_name = part_name
+        """The name of the part in the Abaqus INP file to be used for the geometry."""
+
+    def define_assembly(self):
+        inp = torchfea.FEA_INP()
+        inp.read_inp(self._mesh_file)
+
+        fe_ext = torchfea.from_inp(inp)
+        
+        assembly = torchfea.Assembly()
+
+        assembly.add_part(part=fe_ext.assembly.get_part(self._part_name), name='final_model')
+        instance = torchfea.Instance(part_name='final_model')
+        assembly.add_instance(instance=instance, name='final_model')
+        instance.exterior_surface = 'surface_0_All'
+        return assembly
+
+
+class FixedGeometryTorchFEA(FixedGeometry):
+    """Fixed geometry imported from a model exported by ``torchfea-ui``.
+
+    Only the saved Parts and Instances are used.  MorphOpt creates its own
+    loads, constraints, boundary conditions, reference points, and solver.
+    """
+
+    def __init__(self, model_directory: str, model_filename: str):
+        super().__init__()
+        self.model_directory = str(model_directory)
+        self.model_filename = str(model_filename)
+        # Fail early with a path-specific message while keeping assembly
+        # construction lazy.
+        self.model_path = str(resolve_model_path(
+            self.model_directory, self.model_filename))
+
+    def define_assembly(self) -> torchfea.Assembly:
+        return load_geometry_assembly(
+            self.model_directory, self.model_filename)

{morphopt-3.2.0 → morphopt-3.2.1}/src/morphopt/simp/__init__.py

@@ -6,4 +6,4 @@ This module implements the SIMP (Solid Isotropic Material with Penalization) met
 from .solver import SIMPSolver
 from .update_material import UpdaterMaterials
 from .simpmaterial import SIMP_BSPFieldMaterials
-from ..optcore import FEAParams, HomogeneousMaterial, Solver, Updaters, ObjectiveFunction, Params, FixedGeometry, FixedGeometryINP
+from ..optcore import FEAParams, HomogeneousMaterial, Solver, Updaters, ObjectiveFunction, Params, FixedGeometry, FixedGeometryINP, FixedGeometryTorchFEA

{morphopt-3.2.0 → morphopt-3.2.1}/src/morphopt/simp/objectivefuncs/volfrac.py

@@ -22,7 +22,7 @@ class VolFrac(BaseConstraints):
 
 
     def initialize(self, material_params: SIMP_BSPFieldMaterials, *args, **kwargs):
-        part = morphopt.controller.objfun.fe.assembly.get_part('final_model')
+        part = morphopt.controller.objfun.fe.assembly.get_part(material_params.part_name)
         elems = part.elems[self.element_name]
         self.gaussian_points = elems.get_gaussian_points(part.nodes).reshape(-1, 3)
         self.gaussian_weights = elems.gaussian_weight.flatten()

{morphopt-3.2.0 → morphopt-3.2.1}/src/morphopt/simp/simpmaterial.py

@@ -298,6 +298,18 @@ class SIMPElementHuHu_LuLu(torchfea.elements.Element_3D):
 
         return EmdUe + result0[0], self._EmdUe_2 + result0[1]
 
+class SIMPElementC3D4(torchfea.elements.C3D4, SIMPElementFskew):
+    """C3D4 adapter for the optional SIMP Fskew penalty.
+
+    C3D4 is a linear tetrahedral element, so its second shape-function
+    derivatives are zero and the Fskew term evaluates to zero.  It still
+    needs the adapter when the penalty option is enabled because the
+    sensitivity update refreshes the penalty caches uniformly for all SIMP
+    elements.
+    """
+    pass
+
+
 class SIMPElementC3D10(torchfea.elements.C3D10, SIMPElementFskew):
     pass
 
@@ -355,6 +367,7 @@ class SIMP_BSPFieldMaterials(BaseParams):
                  voidpenalfactor: float = 1e-2,
                  materialpenalty: int = 8,
                  elementname: str = "C3D4",
+                 part_name: str = "",
                  ) -> None:
         """
         Initialize the SIMPMaterials class.
@@ -439,6 +452,9 @@ class SIMP_BSPFieldMaterials(BaseParams):
         self.elementname = elementname
         """ The name of the element type to which the SIMP material will be applied. """
 
+        self.part_name = str(part_name).strip()
+        """Name of the imported Part carrying the SIMP design field."""
+
 
 
 
@@ -675,22 +691,37 @@ class SIMP_BSPFieldMaterials(BaseParams):
         """
 
         # Set the SIMP materials for the solid elements
-        elements = fe.assembly.get_part('final_model').elems[self.elementname]
+        if not self.part_name:
+            raise ValueError("Select the imported Part for the SIMP material.")
+        part = fe.assembly.get_part(self.part_name)
+        elements = part.elems[self.elementname]
 
         if self.if_use_simppenalty:
-            if elements.__class__.__name__ == "C3D10":
+            # The fixed geometry is reused between optimization iterations;
+            # once an element has been wrapped, keep that wrapper instead of
+            # trying to wrap it again based on its new class name.
+            if isinstance(elements, SIMPElementFskew):
+                elements_new = elements
+            elif elements.__class__.__name__ == "C3D4":
+                elements_new = SIMPElementC3D4(elems_index=elements._elems_index, elems=elements._elems, penalfactor=self.voidpenalfactor)
+            elif elements.__class__.__name__ == "C3D10":
                 elements_new = SIMPElementC3D10(elems_index=elements._elems_index, elems=elements._elems, penalfactor=self.voidpenalfactor)
+            elif elements.__class__.__name__ == "C3D8":
+                elements_new = SIMPElementC3D8(elems_index=elements._elems_index, elems=elements._elems, penalfactor=self.voidpenalfactor)
             elif elements.__class__.__name__ == "C3D20":
                 elements_new = SIMPElementC3D20(elems_index=elements._elems_index, elems=elements._elems, penalfactor=self.voidpenalfactor)
             else:
-                elements_new = elements
+                raise ValueError(
+                    f"SIMP Fskew penalty is not implemented for element type "
+                    f"'{elements.__class__.__name__}'. Set voidpenalfactor=0 "
+                    "or use a supported solid element type.")
         else:
             elements_new = elements
 
 
-        fe.assembly.get_part('final_model').elems[self.elementname] = elements_new
+        part.elems[self.elementname] = elements_new
 
-        nodes = fe.assembly.get_part('final_model').nodes
+        nodes = part.nodes
         elements_new._pre_load_gaussian(nodes=nodes)
 
         gaussian_points_locations = elements_new.get_gaussian_points(nodes=nodes)
@@ -742,7 +773,7 @@ class SIMP_BSPFieldMaterials(BaseParams):
         ratio_now = self.get_material_ratio(designfield)
 
 
-        elems: SIMPElementC3D10 = assembly.get_part("final_model").elems[self.elementname]
+        elems: torchfea.elements.Element_3D = assembly.get_part(self.part_name).elems[self.elementname]
         
         elems.materials['material-0']._mu = ratio_now * self._mumax
         elems.materials['material-0']._kappa = ratio_now * self._kappamax
@@ -886,6 +917,7 @@ class SIMP_BSPFieldMaterials(BaseParams):
         Returns:
             torch.Tensor: The normalized Gaussian points.
         """
-        gaussian_points_locations = assembly.get_part('final_model').elems[self.elementname].get_gaussian_points(assembly.get_part('final_model').nodes)
+        part = assembly.get_part(self.part_name)
+        gaussian_points_locations = part.elems[self.elementname].get_gaussian_points(part.nodes)
 
-        return gaussian_points_locations
+        return gaussian_points_locations

{morphopt-3.2.0 → morphopt-3.2.1}/src/morphopt/ui/codegen/generator.py

@@ -16,6 +16,7 @@ from ..model.schemas import (
     SURFACE_TYPES, INTERFACE_TYPES, UPDATER_CATALOG,
 )
 from ..schemes.base import get_template
+from ...optcore.modelparams.geometry import inspect_model
 
 
 # --------------------------------------------------------------------------
@@ -220,7 +221,23 @@ def _emit_geometry_init(a, problem: ProblemDefinition, template) -> None:
     surfaces = problem.surfaces()
     if problem.scheme == "simp":
         geo = problem.geometry or GeometryNode()
-        a(f"                super().__init__(mesh_file={_literal(geo.mesh_file)})")
+        if geo.model_directory and geo.model_filename:
+            model = inspect_model(geo.model_directory, geo.model_filename)
+            _validate_simp_interface_selections(problem, model)
+            material = problem.material
+            if material is not None:
+                parts = {item.name: item for item in model.parts}
+                part_name = str(material.part_name or "").strip()
+                if part_name not in parts:
+                    raise ValueError("Select an imported Part for the SIMP material.")
+                if material.elementname not in parts[part_name].element_types:
+                    raise ValueError(
+                        f"Element {material.elementname!r} does not exist on imported "
+                        f"Part {part_name!r}.")
+        a("                super().__init__(")
+        a(f"                    model_directory={_literal(geo.model_directory)},")
+        a(f"                    model_filename={_literal(geo.model_filename)},")
+        a("                )")
         return
     kw = _geometry_kwargs(problem)
     a(f"                super().__init__({kw})" if kw else "                super().__init__()")
@@ -230,6 +247,56 @@ def _emit_geometry_init(a, problem: ProblemDefinition, template) -> None:
         a(f"                self.add_surface({render_surface_call(srf)})")
 
 
+def _validate_simp_interface_selections(problem: ProblemDefinition, model) -> None:
+    """Validate all Assembly-backed names before emitting runnable source."""
+    instances = {item.name: item for item in model.instances}
+    parts = {item.name: item for item in model.parts}
+    for interface in problem.interfaces():
+        spec = INTERFACE_TYPES.get(interface.interface_type, {})
+        fields_for_type = {field["key"] for field in spec.get("params", [])}
+        for instance_key in ("instance_name", "instance_name1", "instance_name2"):
+            if instance_key not in fields_for_type:
+                continue
+            selected = str(interface.get_field(instance_key, "") or "").strip()
+            if not selected:
+                raise ValueError(
+                    f"Interface {interface.name!r} must select {instance_key}.")
+            if selected not in instances:
+                raise ValueError(
+                    f"Interface {interface.name!r} references unknown TorchFEA "
+                    f"Instance {selected!r}.")
+
+        selections = (
+            ("set_nodes_name", "instance_name", "node_sets"),
+            ("surface_name", "instance_name", "surface_sets"),
+            ("surface_name1", "instance_name1", "surface_sets"),
+            ("surface_name2", "instance_name2", "surface_sets"),
+        )
+        for key, instance_key, set_attribute in selections:
+            if key not in fields_for_type:
+                continue
+            selected = str(interface.get_field(key, "") or "").strip()
+            instance_name = str(interface.get_field(instance_key, "") or "").strip()
+            if not selected:
+                raise ValueError(f"Interface {interface.name!r} must select {key}.")
+            instance = instances.get(instance_name)
+            part = parts.get(instance.part_name) if instance is not None else None
+            available = getattr(part, set_attribute, ()) if part is not None else ()
+            if selected not in available:
+                raise ValueError(
+                    f"Interface {interface.name!r} references unknown {key} "
+                    f"{selected!r} on Instance {instance_name!r}.")
+
+        if "element_name" in fields_for_type:
+            element_name = str(interface.element_name or "").strip()
+            instance = instances.get(str(interface.instance_name or "").strip())
+            part = parts.get(instance.part_name) if instance is not None else None
+            if part is None or element_name not in part.element_types:
+                raise ValueError(
+                    f"Interface {interface.name!r} references unknown element "
+                    f"{element_name!r} on Instance {interface.instance_name!r}.")
+
+
 def _emit_apply_constraints(a, problem: ProblemDefinition, template) -> None:
     geo = problem.geometry or GeometryNode()
     updater = problem.updater