morphopt 3.1.1__py3-none-any.whl

morphopt/optcore/modelparams/feamodel/feainterface/boundaryconditioninterface.py

@@ -0,0 +1,59 @@
+from operator import index
+import torch
+
+from torchfea import FEAController
+from .basefeainterface import BaseFEAInterface
+from torchfea.model.boundarys import Boundary_Condition, Boundary_Condition_RP
+
+
+class BoundaryConditionInterface(BaseFEAInterface):
+    """
+    Nonlinear axial spring connecting a reference point to a fixed ground point.
+    Values order (5 floats): [k, L0, Px, Py, Pz]
+            k: stiffness
+            L0: rest length
+            P*: ground point coordinates
+    """
+
+    def __init__(self, instance_name: str, set_nodes_name: str, index_dof: list[int] = [0, 1, 2]) -> None:
+        self.instance_name = instance_name
+        self.set_nodes_name = set_nodes_name
+        self.index_dof = index_dof
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 0
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        bcobj = Boundary_Condition(instance_name=self.instance_name, set_nodes_name=self.set_nodes_name, indexDoF=self.index_dof)
+        fe.assembly.add_boundary(bcobj, name)
+
+
+class BoundaryConditionRPInterface(BaseFEAInterface):
+    """
+    Reference-point boundary condition (BCRP) interface.
+
+    This interface creates a Boundary_Condition_RP on a reference point and
+    allows updating the prescribed values per degree of freedom.
+
+    - index_dof: list of DoF indices to prescribe (e.g. [0,1,2] for translations)
+    - values: list of floats with the same length as index_dof representing the
+      prescribed values for each specified DoF.
+    """
+
+    def __init__(self, rp_name: str, index_dof: list[int] = [0, 1, 2]) -> None:
+        self.rp_name = rp_name
+        self.index_dof = index_dof
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 0
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        """Create and register the RP boundary condition in the FE assembly."""
+        bcobj = Boundary_Condition_RP(rp_name=self.rp_name, indexDoF=self.index_dof)
+        fe.assembly.add_boundary(bcobj, name)
+
+

morphopt/optcore/modelparams/feamodel/feainterface/contactinterface.py

@@ -0,0 +1,113 @@
+from torchfea import FEAController
+import torch
+from .basefeainterface import BaseFEAInterface
+
+# Prefer the same import style as PressureInterface
+try:
+	from torchfea.model.loads.contact import Contact, ContactSelf  # type: ignore
+except Exception:  # Fallback if package structure differs
+	# Defer import to get_fea_load to avoid import-time failures
+	Contact = None  # type: ignore
+	ContactSelf = None  # type: ignore
+
+
+class ContactInterface(BaseFEAInterface):
+	"""
+	Contact load interface between two instances.
+
+	Notes:
+	- This contact interface has no amplitude values (num_values = 0).
+	  It is registered once and applied as a constraint; no per-step values required.
+	- Penalty parameters can be specified via init args.
+
+	This interface describes a contact constraint between surface1 of instance1
+	and surface2 of instance2. It integrates with LoadsParams so contact loads
+	are injected consistently during solve and sensitivity sub-steps.
+	"""
+
+	def __init__(
+		self,
+		instance_name1: str,
+		surface_name1: str,
+		instance_name2: str,
+		surface_name2: str,
+		penalty_threshold_h: float = 3.0,
+		penalty_start_f: float | None = None,
+		penalty_end_f: float | None = None,
+	) -> None:
+		super().__init__()
+		self.instance_name1 = instance_name1
+		self.surface_name1 = surface_name1
+		self.instance_name2 = instance_name2
+		self.surface_name2 = surface_name2
+		self.penalty_threshold_h = float(penalty_threshold_h)
+		self.penalty_start_f = None if penalty_start_f is None else float(penalty_start_f)
+		self.penalty_end_f = None if penalty_end_f is None else float(penalty_end_f)
+
+	@property
+	def num_values(self) -> int:
+		return 0
+
+	def modify_fea(self, fe: FEAController, name: str):
+
+		# Lazy import to be robust to different package layouts
+		global Contact
+		if Contact is None:
+			from FEA.assemble.loads.contact import Contact as _Contact  # type: ignore
+			Contact = _Contact  # type: ignore
+
+		kwargs = dict(
+			instance_name1=self.instance_name1,
+			instance_name2=self.instance_name2,
+			surface_name1=self.surface_name1,
+			surface_name2=self.surface_name2,
+			penalty_threshold_h=self.penalty_threshold_h,
+		)
+		if self.penalty_start_f is not None:
+			kwargs["penalty_start_f"] = self.penalty_start_f
+		if self.penalty_end_f is not None:
+			kwargs["penalty_end_f"] = self.penalty_end_f
+		loadobj = Contact(**kwargs)  # type: ignore
+
+		fe.assembly.add_load(loadobj, name)
+
+
+
+class ContactSelfInterface(BaseFEAInterface):
+	"""
+	Self-contact load interface for a single instance surface.
+
+	Notes:
+	- This self-contact interface has no amplitude values (num_values = 0).
+	  It is registered once and applied as a constraint; no per-step values required.
+
+	Adds a self-contact constraint for a given surface on one instance.
+	"""
+
+	def __init__(
+		self,
+		instance_name: str,
+		surface_name: str,
+		penalty_threshold_h: float | None = None,
+	) -> None:
+		super().__init__()
+		self.instance_name = instance_name
+		self.surface_name = surface_name
+		self.penalty_threshold_h = None if penalty_threshold_h is None else float(penalty_threshold_h)
+		
+	@property
+	def num_values(self) -> int:
+		return 0
+
+	def modify_fea(self, fe: FEAController, name: str):
+		from torchfea.model.loads.contact import ContactSelf
+
+		kwargs = dict(
+			instance_name=self.instance_name,
+			surface_name=self.surface_name,
+		)
+		if self.penalty_threshold_h is not None:
+			kwargs["penalty_threshold_h"] = self.penalty_threshold_h
+		loadobj = ContactSelf(**kwargs)  # type: ignore
+
+		fe.assembly.add_load(loadobj, name)

morphopt/optcore/modelparams/feamodel/feainterface/coupleinterface.py

@@ -0,0 +1,31 @@
+from operator import index
+import torch
+
+from torchfea import FEAController
+from .basefeainterface import BaseFEAInterface
+from torchfea.model.constraints import Couple
+
+
+class CoupleInterface(BaseFEAInterface):
+    """
+    Nonlinear axial spring connecting a reference point to a fixed ground point.
+    Values order (5 floats): [k, L0, Px, Py, Pz]
+            k: stiffness
+            L0: rest length
+            P*: ground point coordinates
+    """
+
+    def __init__(self, rp_name: str, instance_name: str, set_nodes_name: str) -> None:
+        self.rp_name = rp_name
+        self.instance_name = instance_name
+        self.set_nodes_name = set_nodes_name
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 0
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        loadobj = Couple(instance_name=self.instance_name, set_nodes_name=self.set_nodes_name, rp_name=self.rp_name)
+        fe.assembly.add_constraint(loadobj, name)
+

morphopt/optcore/modelparams/feamodel/feainterface/pointinterface.py

@@ -0,0 +1,79 @@
+import numpy as np
+import torch
+
+from torchfea import FEAController
+from .basefeainterface import BaseFEAInterface
+from torchfea.model.loads import Concentrate_Force, Moment
+
+
+class ConcentratedForceInterface(BaseFEAInterface):
+    """
+    Concentrated (point) force load interface.
+
+    Applies a force vector at a reference point (RP).
+
+    Values (list[float], length=3):
+    - [0] Fx, [1] Fy, [2] Fz
+    """
+
+    def __init__(self, rp_name: str) -> None:
+        self.rp_name = rp_name
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 3
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        loadobj = Concentrate_Force(rp_name=self.rp_name, force=self.force)
+        fe.assembly.add_load(loadobj, name)
+
+    def apply_fea_value(self, fe: FEAController, name: str) -> None:
+        fe.assembly.get_load(name).force = self.force
+
+    @property
+    def force(self) -> list[float]:
+        return self._values.copy()
+
+    @force.setter
+    def force(self, value: list[float]) -> None:
+        if len(value) != 3:
+            raise ValueError("force must be a list of 3 floats [Fx, Fy, Fz].")
+        self._values = list(map(float, value))
+
+
+class ConcentratedMomentInterface(BaseFEAInterface):
+    """
+    Concentrated (point) moment load interface.
+
+    Applies a moment vector at a reference point (RP).
+
+    Values (list[float], length=3):
+    - [0] Mx, [1] My, [2] Mz
+    """
+
+    def __init__(self, rp_name: str) -> None:
+        super().__init__()
+        self.rp_name = rp_name
+
+    @property
+    def num_values(self) -> int:
+        return 3
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        loadobj = Moment(rp_name=self.rp_name, moment=self.moment)
+        fe.assembly.add_load(loadobj, name)
+
+    def apply_fea_value(self, fe: FEAController, name: str) -> None:
+        fe.assembly.get_load(name).moment = self.moment
+
+    @property
+    def moment(self) -> list[float]:
+        return self._values.copy()
+
+    @moment.setter
+    def moment(self, value: list[float]) -> None:
+        if len(value) != 3:
+            raise ValueError("moment must be a list of 3 floats [Mx, My, Mz].")
+        self._values = list(map(float, value))
+

morphopt/optcore/modelparams/feamodel/feainterface/pressureinterface.py

@@ -0,0 +1,68 @@
+
+from torchfea import FEAController
+import numpy as np
+import torch
+from .basefeainterface import BaseFEAInterface
+from torchfea.model.loads import Pressure
+class PressureInterface(BaseFEAInterface):
+    """
+    Surface pressure load interface.
+
+    Values (list[float], length=1):
+    - [0] pressure (scalar)
+    """
+
+    def __init__(self, surface_name: str, instance_name: str = 'final_model'):
+        """
+        Initialize the PressureInterface class with default values.
+        """
+        super().__init__()
+        """
+        pressure: A 2D list to hold the pressure values.
+        """
+        self.instance_name = instance_name
+        """
+        instance_name: The name of the instance.
+        """
+        self.surface_name = surface_name
+        """
+        surface_name: The name of the surface.
+        """
+
+    @property
+    def pressure(self) -> float:
+        """
+        Get the pressure values.
+
+        Returns:
+            float: The pressure values.
+        """
+        return float(self._values[0])
+    
+    @pressure.setter
+    def pressure(self, value: float) -> None:
+        """
+        Set the pressure values.
+
+        Args:
+            value (float): The new pressure value.
+        """
+        self._values = [float(value)]
+
+    @property
+    def num_values(self) -> int:
+        """
+        Get the number of pressure variables.
+
+        Returns:
+            int: The number of pressure variables.
+        """
+        return 1
+    
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        pressure_load = Pressure(instance_name=self.instance_name,surface_set=self.surface_name,pressure=self.pressure)
+        fe.assembly.add_load(pressure_load, name)
+    
+    def apply_fea_value(self, fe: FEAController, name: str) -> None:
+        pressure_load: Pressure = fe.assembly.get_load(name)
+        pressure_load.pressure = self.pressure

morphopt/optcore/modelparams/feamodel/feainterface/referencepointinterface.py

@@ -0,0 +1,29 @@
+from operator import index
+import torch
+
+from torchfea import FEAController
+from .basefeainterface import BaseFEAInterface
+from torchfea.model import ReferencePoint
+
+
+class ReferencePointInterface(BaseFEAInterface):
+    """
+    Nonlinear axial spring connecting a reference point to a fixed ground point.
+    Values order (5 floats): [k, L0, Px, Py, Pz]
+            k: stiffness
+            L0: rest length
+            P*: ground point coordinates
+    """
+
+    def __init__(self, rp_location: list[float]) -> None:
+        self.rp_location = rp_location
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 0
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        rp = ReferencePoint(node=self.rp_location)
+        fe.assembly.add_reference_point(rp, name)
+

morphopt/optcore/modelparams/feamodel/feainterface/springinterface.py

@@ -0,0 +1,104 @@
+import torch
+
+from torchfea import FEAController
+from .basefeainterface import BaseFEAInterface
+from torchfea.model.loads.spring import Spring_RP_Point, Spring_RP_RP
+
+
+class SpringToGroundInterface(BaseFEAInterface):
+    """
+    Nonlinear axial spring connecting a reference point to a fixed ground point.
+    Values order (5 floats): [k, L0, Px, Py, Pz]
+            k: stiffness
+            L0: rest length
+            P*: ground point coordinates
+    """
+
+    def __init__(self, rp_name: str) -> None:
+        self.rp_name = rp_name
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 5
+
+    # Convenience accessors
+    @property
+    def k(self) -> float:
+        return float(self._values[0])
+
+    @k.setter
+    def k(self, value: float) -> None:
+        self._values[0] = float(value)
+
+    @property
+    def rest_length(self) -> float:
+        return float(self._values[1])
+
+    @rest_length.setter
+    def rest_length(self, value: float) -> None:
+        self._values[1] = float(value)
+
+    @property
+    def point(self) -> list[float]:
+        return [float(self._values[2]), float(self._values[3]), float(self._values[4])]
+
+    @point.setter
+    def point(self, value: list[float]) -> None:
+        if len(value) != 3:
+            raise ValueError("point must be a list of 3 floats [x, y, z].")
+        self._values[2:5] = [float(value[0]), float(value[1]), float(value[2])]
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        loadobj = Spring_RP_Point(rp_name=self.rp_name, point=self.point, k=self.k, rest_length=self.rest_length)
+        fe.assembly.add_load(loadobj, name)
+
+    def apply_fea_value(self, fe: FEAController, name: str) -> None:
+        loadobj: Spring_RP_Point = fe.assembly.get_load(name)
+        loadobj.k = self.k
+        loadobj.rest_length = self.rest_length
+        loadobj.point = self.point
+
+
+class SpringBetweenRPsInterface(BaseFEAInterface):
+    """
+    Nonlinear axial spring connecting two reference points (RP-RP).
+
+    Values order (2 floats): [k, L0]
+      - k: stiffness
+      - L0: rest length
+    """
+
+    def __init__(self, rp_name1: str, rp_name2: str) -> None:
+        self.rp_name1 = rp_name1
+        self.rp_name2 = rp_name2
+        super().__init__()
+
+    @property
+    def num_values(self) -> int:
+        return 2
+
+    @property
+    def k(self) -> float:
+        return float(self._values[0])
+
+    @k.setter
+    def k(self, value: float) -> None:
+        self._values[0] = float(value)
+
+    @property
+    def rest_length(self) -> float:
+        return float(self._values[1])
+
+    @rest_length.setter
+    def rest_length(self, value: float) -> None:
+        self._values[1] = float(value)
+
+    def modify_fea(self, fe: FEAController, name: str) -> None:
+        loadobj = Spring_RP_RP(rp_name1=self.rp_name1, rp_name2=self.rp_name2, k=self.k, rest_length=self.rest_length)
+        fe.assembly.add_load(loadobj, name)
+
+    def apply_fea_value(self, fe: FEAController, name: str) -> None:
+        loadobj: Spring_RP_RP = fe.assembly.get_load(name)
+        loadobj.k = self.k
+        loadobj.rest_length = self.rest_length