morphopt 3.1.6__tar.gz → 3.2.1__tar.gz

morphopt-3.2.1/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: morphopt
+Version: 3.2.1
+Summary: A morphing optimization framework using PyTorch and Abaqus.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.9.1
+Requires-Dist: torchvision>=0.15.1
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pypardiso>=0.4.7
+Requires-Dist: pyside6>=6.8.0
+Requires-Dist: pyvista>=0.47.1
+Requires-Dist: pyvistaqt>=0.11.3
+Requires-Dist: vtk>=9.6.1
+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: trimesh>=4.11.5
+Requires-Dist: networkx>=3.6.1
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: cpgeo>=1.0.12
+
+# MorphOpt — A Differentiable Optimization Framework for Soft Structure & Morphology Design
+
+**Developed by Zenan Song**
+
+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.
+
+## Features
+
+- Custom model definition covering geometry, material, and load parameters
+- Differentiable FEA via torchfea with automatic solving and sensitivity propagation
+- L-BFGS and trust-region methods for parameter updates within a subproblem framework
+- Fully extensible via inheritance — users customize every component in their definition scripts
+
+## Quick Start
+
+Install the package:
+
+```bash
+pip install morphopt
+```
+
+Requirements: Python ≥ 3.12; a PyTorch **float64** build is recommended.
+
+> **Optimizations are run as scripts.** Each job is an ordinary Python file that calls `morphopt.start_optimization(...)`. It runs headlessly in a terminal (local or remote), and a finished run can be stopped and resumed later from its result folder. Script execution is the recommended way to run jobs.
+
+1. **Run a minimal example** — execute it directly in a terminal:
+
+   ```bash
+   # Shape optimization (pneumatic bending actuator)
+   python examples/bendingactuator.py
+
+   # SIMP topology optimization (compliant gripper)
+   python examples/gripper.py
+   ```
+
+2. **Run your own job** — copy an example as a starting point, adapt the definition (geometry, material, load, updater, objective), and launch it as a script:
+
+   ```bash
+   python my_task.py
+   ```
+
+   Each run writes its results (logs, FEA files, restart script) into a timestamped result folder under the run root.
+
+3. **Optional — the GUI** is a visual aid for authoring a problem definition and inspecting finished runs in one window. It can also export a runnable script (`.py`), which you can either run directly in the UI or further customize before executing it via Step 2 in a terminal.
+
+   ```bash
+   morphopt-ui            # console command, available after `pip install morphopt`
+   # python -m morphopt.ui works too (handy when running from a source code directory)
+   ```
+
+The complete UI workflow (definition part + observer part) is described in [`docs/UI_usage.md`](docs/UI_usage.md).
+
+Further references:
+
+- Task definition guide: `docs/module_definition_guide.md`
+- Module API reference: `docs/module_reference.md`
+- Theory & papers: `docs/theory/`
+
+## Directory Overview
+
+- `src/morphopt/`
+  - `optcore` — Core package (controller, params, solver, objective, updaters)
+  - `shapeopt/` — B-spline shape optimization
+  - `simp/` — SIMP topology optimization
+  - `codesign/` — Shell co-design (shape + material)
+  - `ui/` — PySide6 graphical UI (definition + observer in one window)
+- `examples/` — Example tasks (bending actuator, gripper, etc.)
+- `docs/` — Usage guides, API reference, theory papers
+- `tests/` — Gradient checks, geometry tests, UI tests
+- `ui_runs/` — runs launched from the UI and their results (`<label>_T<timestamp>/`)
+
+## License
+
+Research use preferred. For production or commercial use, please evaluate and ensure numerical and engineering robustness first.
+
+## Citation
+
+If you use MorphOpt in your research, please cite:
+
+- TRO 2023
+
+```
+@ARTICLE{10296178,
+  author={Chen, Feifei and Song, Zenan and Chen, Shitong and Gu, Guoying and Zhu, Xiangyang},
+  journal={IEEE Transactions on Robotics}, 
+  title={Morphological Design for Pneumatic Soft Actuators and Robots With Desired Deformation Behavior}, 
+  year={2023},
+  volume={39},
+  number={6},
+  pages={4408-4428},
+  keywords={Shape;Surface morphology;Robots;Splines (mathematics);Pneumatic systems;Actuators;Soft robotics;Morphological design;shape optimization;pneumatic soft robots},
+  doi={10.1109/TRO.2023.3323825}}
+```
+
+- TRO 2026
+
+```
+@ARTICLE{11617347,
+  author={Song, Zenan and Chen, Feifei and Gu, Guoying and Zhu, Xiangyang},
+  journal={IEEE Transactions on Robotics}, 
+  title={Continuum Jacobian-Based Computational Morphogenesis for Soft Robotic Workspace Optimization}, 
+  year={2026},
+  volume={42},
+  number={},
+  pages={3048-3068},
+  keywords={Optimization;Design methodology;Surfaces;Modeling;End effectors;Shape;Soft robotics;Deformation;Vectors;Robots;Computational morphogenesis;Jacobian shape derivative;soft robotics;workspace optimization},
+  doi={10.1109/TRO.2026.3716051}}
+
+```
+
+- TMECH 2026
+
+```
+@ARTICLE{11536090,
+  author={Song, Zenan and Zhou, Guozhen and Chen, Feifei},
+  journal={IEEE/ASME Transactions on Mechatronics}, 
+  title={Contact-Aware Soft Robot Design via Differentiable Simulation and Morphological Optimization}, 
+  year={2026},
+  volume={31},
+  number={4},
+  pages={4576-4584},
+  keywords={Contacts;Optimization;Modeling;Design methodology;Soft robotics;Surfaces;Actuators;Materials;Force;Simulation;Differentiable contact modeling;morphological design;soft robotics},
+  doi={10.1109/TMECH.2026.3692920}}
+
+```
+
+

morphopt-3.2.1/README.md

@@ -0,0 +1,127 @@
+# MorphOpt — A Differentiable Optimization Framework for Soft Structure & Morphology Design
+
+**Developed by Zenan Song**
+
+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.
+
+## Features
+
+- Custom model definition covering geometry, material, and load parameters
+- Differentiable FEA via torchfea with automatic solving and sensitivity propagation
+- L-BFGS and trust-region methods for parameter updates within a subproblem framework
+- Fully extensible via inheritance — users customize every component in their definition scripts
+
+## Quick Start
+
+Install the package:
+
+```bash
+pip install morphopt
+```
+
+Requirements: Python ≥ 3.12; a PyTorch **float64** build is recommended.
+
+> **Optimizations are run as scripts.** Each job is an ordinary Python file that calls `morphopt.start_optimization(...)`. It runs headlessly in a terminal (local or remote), and a finished run can be stopped and resumed later from its result folder. Script execution is the recommended way to run jobs.
+
+1. **Run a minimal example** — execute it directly in a terminal:
+
+   ```bash
+   # Shape optimization (pneumatic bending actuator)
+   python examples/bendingactuator.py
+
+   # SIMP topology optimization (compliant gripper)
+   python examples/gripper.py
+   ```
+
+2. **Run your own job** — copy an example as a starting point, adapt the definition (geometry, material, load, updater, objective), and launch it as a script:
+
+   ```bash
+   python my_task.py
+   ```
+
+   Each run writes its results (logs, FEA files, restart script) into a timestamped result folder under the run root.
+
+3. **Optional — the GUI** is a visual aid for authoring a problem definition and inspecting finished runs in one window. It can also export a runnable script (`.py`), which you can either run directly in the UI or further customize before executing it via Step 2 in a terminal.
+
+   ```bash
+   morphopt-ui            # console command, available after `pip install morphopt`
+   # python -m morphopt.ui works too (handy when running from a source code directory)
+   ```
+
+The complete UI workflow (definition part + observer part) is described in [`docs/UI_usage.md`](docs/UI_usage.md).
+
+Further references:
+
+- Task definition guide: `docs/module_definition_guide.md`
+- Module API reference: `docs/module_reference.md`
+- Theory & papers: `docs/theory/`
+
+## Directory Overview
+
+- `src/morphopt/`
+  - `optcore` — Core package (controller, params, solver, objective, updaters)
+  - `shapeopt/` — B-spline shape optimization
+  - `simp/` — SIMP topology optimization
+  - `codesign/` — Shell co-design (shape + material)
+  - `ui/` — PySide6 graphical UI (definition + observer in one window)
+- `examples/` — Example tasks (bending actuator, gripper, etc.)
+- `docs/` — Usage guides, API reference, theory papers
+- `tests/` — Gradient checks, geometry tests, UI tests
+- `ui_runs/` — runs launched from the UI and their results (`<label>_T<timestamp>/`)
+
+## License
+
+Research use preferred. For production or commercial use, please evaluate and ensure numerical and engineering robustness first.
+
+## Citation
+
+If you use MorphOpt in your research, please cite:
+
+- TRO 2023
+
+```
+@ARTICLE{10296178,
+  author={Chen, Feifei and Song, Zenan and Chen, Shitong and Gu, Guoying and Zhu, Xiangyang},
+  journal={IEEE Transactions on Robotics}, 
+  title={Morphological Design for Pneumatic Soft Actuators and Robots With Desired Deformation Behavior}, 
+  year={2023},
+  volume={39},
+  number={6},
+  pages={4408-4428},
+  keywords={Shape;Surface morphology;Robots;Splines (mathematics);Pneumatic systems;Actuators;Soft robotics;Morphological design;shape optimization;pneumatic soft robots},
+  doi={10.1109/TRO.2023.3323825}}
+```
+
+- TRO 2026
+
+```
+@ARTICLE{11617347,
+  author={Song, Zenan and Chen, Feifei and Gu, Guoying and Zhu, Xiangyang},
+  journal={IEEE Transactions on Robotics}, 
+  title={Continuum Jacobian-Based Computational Morphogenesis for Soft Robotic Workspace Optimization}, 
+  year={2026},
+  volume={42},
+  number={},
+  pages={3048-3068},
+  keywords={Optimization;Design methodology;Surfaces;Modeling;End effectors;Shape;Soft robotics;Deformation;Vectors;Robots;Computational morphogenesis;Jacobian shape derivative;soft robotics;workspace optimization},
+  doi={10.1109/TRO.2026.3716051}}
+
+```
+
+- TMECH 2026
+
+```
+@ARTICLE{11536090,
+  author={Song, Zenan and Zhou, Guozhen and Chen, Feifei},
+  journal={IEEE/ASME Transactions on Mechatronics}, 
+  title={Contact-Aware Soft Robot Design via Differentiable Simulation and Morphological Optimization}, 
+  year={2026},
+  volume={31},
+  number={4},
+  pages={4576-4584},
+  keywords={Contacts;Optimization;Modeling;Design methodology;Soft robotics;Surfaces;Actuators;Materials;Force;Simulation;Differentiable contact modeling;morphological design;soft robotics},
+  doi={10.1109/TMECH.2026.3692920}}
+
+```
+
+

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

@@ -1,6 +1,6 @@
 [project]
 name = "morphopt"
-version = "3.1.6"
+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.0.17",
+    "torchfea>=1.1.1",
     "trimesh>=4.11.5",
     "networkx>=3.6.1",
     "scipy>=1.17.1",

{morphopt-3.1.6 → 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.1.6 → morphopt-3.2.1}/src/morphopt/codesign/feaparams.py

@@ -40,7 +40,7 @@ class CodesignFEAParams(FEAParams):
             )
             surfcenter = surfnodes.mean(dim=1)
 
-            fe.assembly.get_instance('final_model').external_surface = 'surface_1_offset'
+            fe.assembly.get_instance('final_model').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')
@@ -72,4 +72,4 @@ class CodesignFEAParams(FEAParams):
 
             raise ValueError("The Gaussian weights of the C3D6 elements are negative. Please check the mesh quality.")
         
-        return fe
+        return fe

{morphopt-3.1.6 → morphopt-3.2.1}/src/morphopt/opt_runner.py

@@ -2,8 +2,8 @@
 
 Runs started from *code* never open a UI: the PySide6 observer lives inside the
 MorphOpt UI and simply polls the result folder on disk (per finished
-iteration).  The old ``no_gui`` flag and the separate observer process were
-therefore removed; ``view_optimization_result`` lives on the UI side now.
+iteration).  The old ``no_gui`` flag and separate observer process were
+therefore removed; browse results from the observer page in the main UI.
 """
 
 

{morphopt-3.1.6 → 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.1.6 → 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.1.6 → morphopt-3.2.1}/src/morphopt/shapeopt/geometryparams.py

@@ -640,7 +640,9 @@ class GeometryParams(BaseGeometry):
         assembly = torchfea.Assembly()
 
         assembly.add_part(part=part, name='final_model')
-        assembly.add_instance(instance=torchfea.Instance(part_name='final_model', external_surface='surface_0_All'), 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
 
     def _regenerate(self, path_result: str, pools = None):
@@ -776,4 +778,3 @@ class GeometryParams(BaseGeometry):
             nodes_new[part.mid_pt_idxmap_torch[:, 2]] = (nodes_new[part.mid_pt_idxmap_torch[:, 0]] + nodes_new[part.mid_pt_idxmap_torch[:, 1]]) / 2
 
         part.nodes = nodes_new
-        

{morphopt-3.1.6 → 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.1.6 → 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()