morphopt 3.1.1__py3-none-any.whl

morphopt/optcore/updaters/base_updater.py

@@ -0,0 +1,110 @@
+
+
+import torch
+from ..modelparams.base_params import BaseParams
+from ..modelparams.params import Params
+from . import optimizer
+from ..baseobject import BaseObject
+
+class BaseUpdater(BaseObject):
+    """
+    Base class for all Updaters.
+    """
+
+    def __init__(self, params: Params, *args, **kwargs):
+        """
+        Initialize the BaseUpdater.
+        """
+        self.max_step_iter = 50
+        """Maximum number of iterations for the sub-optimization process.
+        """
+        
+        self.obj_funcs: dict[str, callable] = {}
+        """A dictionary of objective functions to be optimized.
+        The keys are the names of the functions, and the values are the functions themselves.
+        """
+        
+        self.params_update: BaseParams = None
+        """The parameters of the optimization process.
+        This should be set to an instance of a subclass of BaseParams.
+        """
+        
+        self.params: Params = params
+        """The parameters of optimization process.
+        This should be set to an instance of the Params class.
+        """
+        
+        self.optimizer: optimizer.BaseOpt
+        """The optimization algorithm used to update the design variables.
+        This should be set to an instance of a subclass of Optimizer.BaseOpt.
+        """
+        
+        self.iteration_total = 0
+        """
+        The total number of iterations performed in the optimization process.
+        """
+                
+        self.U_dim: list[int] = []
+        """U_dim: The dimensions of the interest for the optimization problem.
+        This is a list of integers representing the dimensions of the displacement vector.
+        """
+    
+    def reinitialize(self, iter_now: int, sensitivity: list[torch.Tensor]) -> None:
+        """
+        reInitialize the updater with the current iteration and sensitivity.
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+        
+    def initialize(self) -> None:
+        """
+        Initialize the updater.
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+
+    def _get_sensitivity(self) -> tuple[torch.Tensor, list[torch.Tensor]]:
+        """
+        Get the sensitivity of the elements based on the provided objective function.
+        
+        Parameters:
+            fe_result (FE_result): The finite element analysis result containing the displacement and Jacobian.
+            obj_fun (callable): The objective function to be used for sensitivity analysis.
+        
+        Returns:
+            tuple: A tuple containing:
+                - Loss (torch.Tensor): The loss value.
+                - sensitivity (list[torch.Tensor]): A list of sensitivity tensors for each surface.
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+    
+    def _refine_sensitivity(self, iter_now: int, sensitivity: list[torch.Tensor]) -> list[torch.Tensor]:
+        """
+        Refine the sensitivity values based on the current iteration.
+        
+        Parameters:
+            iter_now (int): The current iteration number.
+            sensitivity (list[torch.Tensor]): The sensitivity tensors to be refined.
+        
+        Returns:
+            list[torch.Tensor]: The refined sensitivity tensors.
+        """
+        # This method can be overridden by subclasses if needed
+        return sensitivity
+    
+    def closure(self, x: torch.Tensor, return_list: bool = False) -> torch.Tensor:
+        """
+        This method is called to update the design variables based on the optimization algorithm used.
+        
+        Parameters:
+            x (torch.Tensor): The current design variables.
+            return_list (bool): If True, returns a list of objective function values; otherwise, returns their sum.
+        
+        Returns:
+            torch.Tensor: The objective function value(s).
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+    
+    def update_variables(self, dx: torch.Tensor) -> None:
+        """
+        Update the variables of the surfaces.
+        """
+        pass

morphopt/optcore/updaters/geometry/__init__.py

@@ -0,0 +1,2 @@
+from .update_geometry import UpdaterGeometries
+from . import objectivefuncs

morphopt/optcore/updaters/geometry/objectivefuncs/__init__.py

@@ -0,0 +1,5 @@
+from .basefuncs import BaseConstraints, BaseObjective
+from .shapederivative import ShapeDerivativeDisplacement
+from .surfacefairness import Fairness
+from . import boundarys
+from .distancesurface import Distance

morphopt/optcore/updaters/geometry/objectivefuncs/basefuncs.py

@@ -0,0 +1,117 @@
+import torch
+
+
+class BaseConstraints():
+    """
+    Base class for objective functions in MorphOpt.
+    """
+
+    def __init__(self):
+        """
+        Initialize the objective function.
+        """
+        self.scaler: list[torch.Tensor] = []
+        """
+        The scaler to process the objective function.
+        """
+
+
+    def initialize(self, r0: list[torch.Tensor], rdu0: list[torch.Tensor], rdu20: list[torch.Tensor], sensitivity: list[torch.Tensor], weights: list[torch.Tensor], *args, **kwargs):
+        
+        self.scaler = []
+        for i in range(len(sensitivity)):
+            sen_now = sensitivity[i].reshape([-1, 3]).norm(dim=1)
+            if (sen_now != 0).any():
+                sen_now[sen_now==0] = sen_now[sen_now!=0].min()
+            else:
+                sen_now = torch.ones_like(sen_now)  # Fallback if all zeros
+            self.scaler.append(sen_now * weights[i])
+
+    def __call__(self, r: list[torch.Tensor], rdu: list[torch.Tensor], rdu2: list[torch.Tensor], weights: list[torch.Tensor], *args, **kwargs) -> float:
+        """
+        Call the objective function.
+
+        Args:
+            weight (list[torch.Tensor]): The weights for each point.
+            r (list[torch.Tensor]): The point coordinates of the surfaces.
+            rdu (list[torch.Tensor]): The partial derivatives of the surfaces.
+            rdu2 (list[torch.Tensor]): The second partial derivatives of the surfaces.
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            The value of the objective function.
+        """
+        raise NotImplementedError("Objective function not implemented.")
+    
+    @staticmethod
+    def barrier_function(f: torch.Tensor, f_max: torch.Tensor|float, ratio: float, p: int):
+        """
+        Apply a barrier function to the objective function.
+        
+        Args:
+            f (torch.Tensor): The objective function value.
+            f_max (float or torch.Tensor): The maximum value of the objective function.
+            ratio (float): The ratio for the barrier function.
+            p (float): The exponent for the barrier function.
+            
+        Returns:
+            index (torch.Tensor): The indices of the elements that are greater than the barrier.
+            fnew (torch.Tensor): The new objective function value after applying the barrier function.
+        
+        """
+        if type(f_max) != torch.Tensor:
+            f_max = torch.tensor(f_max).repeat(f.shape)
+        index = torch.where(f > f_max * ratio)[0]
+
+        if index.numel() > 0:
+            f = f[index]
+            f_max = f_max[index]
+            fnew = ((f - f_max * ratio) / (f_max - f_max * ratio))**(p)
+        else:
+            f = f[index]
+            fnew = torch.zeros_like(f)
+        return index, fnew
+    
+
+class BaseObjective():
+    """
+    Base class for objective functions in MorphOpt.
+    """
+
+    def __init__(self):
+        """
+        Initialize the objective function.
+        """
+        self.sensitivity: list[torch.Tensor] = []
+        """
+        Sensitivity of the shape derivative with respect to the contact forces.
+        """
+
+    def initialize(self, r0: list[torch.Tensor], rdu0: list[torch.Tensor], rdu20: list[torch.Tensor], weights: list[torch.Tensor], *args, **kwargs) -> None:
+        """
+        Initialize the objective function with the given parameters.
+
+        Args:
+            weights (list[torch.Tensor]): The weights for each point.
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+        """
+        pass
+
+    def __call__(self, r: list[torch.Tensor], rdu: list[torch.Tensor], rdu2: list[torch.Tensor], *args, **kwargs) -> float:
+        """
+        Call the objective function.
+
+        Args:
+            weight (list[torch.Tensor]): The weights for each point.
+            r (list[torch.Tensor]): The point coordinates of the surfaces.
+            rdu (list[torch.Tensor]): The partial derivatives of the surfaces.
+            rdu2 (list[torch.Tensor]): The second partial derivatives of the surfaces.
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            The value of the objective function.
+        """
+        raise NotImplementedError("Objective function not implemented.")

morphopt/optcore/updaters/geometry/objectivefuncs/boundarys.py

@@ -0,0 +1,91 @@
+
+import torch
+from .basefuncs import BaseConstraints
+
+
+class MinRadius(BaseConstraints):
+    """
+    Cylinder boundary objective function for MorphOpt.
+    """
+
+    def __init__(self, radius: float) -> None:
+        """
+        Initialize the Cylinder objective function.
+        """
+        super().__init__()
+
+        self._radius = radius
+        """
+        The radius of the cylinder.
+        """
+
+
+    def __call__(self, r, rdu, rdu2, *args, **kwargs):
+        
+        thre = 0.05
+        degree = 3
+        
+        loss = torch.zeros(1, device=r[0].device, dtype=r[0].dtype)
+        for i in range(len(r)):
+            
+            length_r = -(r[i][:, 0]**2 + r[i][:, 1]**2).sqrt() + self._radius
+            
+            index_r, loss_r = self.barrier_function(length_r, thre, 0., degree)
+
+            
+            if len(index_r) > 0:
+                loss = loss + (self.scaler[i][index_r] * loss_r).sum()
+            
+        return loss
+    
+
+class Cylinder(BaseConstraints):
+    """
+    Cylinder boundary objective function for MorphOpt.
+    """
+
+    def __init__(self, radius: float, height: float, bottom: float) -> None:
+        """
+        Initialize the Cylinder objective function.
+        """
+        super().__init__()
+
+        self._radius = radius
+        """
+        The radius of the cylinder.
+        """
+        
+        self._height = height + 1
+        """
+        The height of the cylinder.
+        """
+        
+        self._bottom = bottom - 1
+        """
+        The bottom of the cylinder.
+        """
+
+    def __call__(self, r, rdu, rdu2, *args, **kwargs):
+        
+        thre = 0.05
+        degree = 3
+        
+        loss = torch.zeros(1, device=r[0].device, dtype=r[0].dtype)
+        for i in range(len(r)):
+            
+            length_r = (r[i][:, 0]**2 + r[i][:, 1]**2).sqrt() - self._radius
+            length_bottom = -r[i][:, 2] + self._bottom
+            length_top = r[i][:, 2] - self._height
+            
+            index_r, loss_r = self.barrier_function(length_r, thre, 0., degree)
+            index_bottom, loss_bottom = self.barrier_function(length_bottom, thre, 0., degree)
+            index_top, loss_top = self.barrier_function(length_top, thre, 0., degree)
+            
+            if len(index_r) > 0:
+                loss = loss + (self.scaler[i][index_r] * loss_r).sum()
+            if len(index_bottom) > 0:
+                loss = loss + (self.scaler[i][index_bottom] * loss_bottom).sum()
+            if len(index_top) > 0:
+                loss = loss + (self.scaler[i][index_top] * loss_top).sum()
+            
+        return loss

morphopt/optcore/updaters/geometry/objectivefuncs/distancesurface.py

@@ -0,0 +1,123 @@
+
+import torch
+from .basefuncs import BaseConstraints
+import logging
+
+class Distance(BaseConstraints):
+    """
+    Distance objective function for MorphOpt.
+    """
+
+    def __init__(self, min_distance: list[list[float]]):
+        """
+        Initialize the Distance objective function with a name.
+        """
+        super().__init__()
+
+        self.neighbor_points: torch.Tensor
+        """
+        The neighbor points of the surfaces that need to be checked for distance.
+        """
+
+        self.points_surface_index: torch.Tensor
+        """
+        The index of the surfaces for each point.
+        """
+
+        self.neighbor_mindist: torch.Tensor
+        """
+        The allowable minimum distance between the points.
+        """
+
+        self.min_distance = torch.tensor(min_distance).to(torch.float32)
+        """
+        The minimum distance between the surfaces.
+            [i, j] the minimum distance between surface i and surface j.
+        """
+
+        self.distance_threshold = max(self.min_distance.flatten()).item() * 1.5
+        """
+        The distance threshold for the distance penalty.
+        """
+
+    def initialize(self, r0, rdu0, *args, **kwargs) -> None:
+        """
+        Initialize the Distance objective function with the surface points and their derivatives.
+        Parameters:
+            r0 (list[torch.Tensor]): List of surface points.
+            rdu0 (list[torch.Tensor]): List of surface point derivatives.
+        """
+
+        super().initialize(r0=r0, rdu0=rdu0, *args, **kwargs)
+        
+        # prepare the normal vector for each surface
+        normal0 = []
+        for i in range(len(r0)):
+            normal_vector = torch.cross(rdu0[i][:, :, 1], rdu0[i][:, :, 0], dim=1)
+            normal_vector /= normal_vector.norm(dim=1, keepdim=True)
+            normal0.append(normal_vector.detach().clone())
+
+        num_points_total = []
+        index_Surf = []
+        for i in range(len(r0)):
+            index_Surf.append(torch.ones(r0[i].shape[0]) * i)
+            num_points_total += [r0[i].shape[0]]
+
+        normal0 = torch.cat(normal0, dim=0).type(torch.float32)
+        
+        self.points_surface_index = torch.cat(index_Surf,
+                                              dim=0).type(torch.int64)
+
+        
+        # get the neighbor points
+        import scipy.spatial
+        kdtree = scipy.spatial.KDTree(torch.cat(r0, dim=0).cpu().numpy())
+        self.neighbor_points = kdtree.query_pairs(r=self.distance_threshold, output_type='ndarray').T
+
+        self.neighbor_points = torch.from_numpy(self.neighbor_points).type(torch.int64).to(r0[0].device)
+
+        # determine the minimum distance between the neighbor points
+        self.neighbor_mindist = torch.zeros(self.neighbor_points.shape[1], dtype=torch.float32)
+        for i in range(self.min_distance.shape[0]):
+            for j in range(self.min_distance.shape[1]):
+                # Find indices where points are from surface i and j
+                index = torch.where(
+                    (self.points_surface_index[self.neighbor_points[0]] == i) &
+                    (self.points_surface_index[self.neighbor_points[1]] == j))[0]
+                
+                if len(index) > 0:
+                    if i == j:  # Same surface case
+                        # Use normal vector direction to determine distance for same surface
+                        self.neighbor_mindist[index] = self.min_distance[i, j] * (-normal0[self.neighbor_points[0][index], :] *
+                            normal0[self.neighbor_points[1][index], :]).sum(dim=1)
+                    else:  
+                        # Different surfaces
+                        self.neighbor_mindist[index] = self.min_distance[i, j]
+
+        index_pos = self.neighbor_mindist > 0
+        self.neighbor_points = self.neighbor_points[:, index_pos]
+        self.neighbor_mindist = self.neighbor_mindist[index_pos]
+
+        logging.debug(f"Distance Objective Function: {self.neighbor_points.shape[1]} point pairs within threshold {self.distance_threshold}")
+
+    def __call__(self, r, *args, **kwargs):
+
+        R = torch.cat(r, dim=0).type(torch.float32)
+        thre = 0.02
+        degree = 5
+        loss_distance = torch.tensor(0.0, dtype=torch.float32)
+        weight_flatten = torch.cat(self.scaler, dim=0).type(torch.float32)
+        if torch.numel(self.neighbor_points) != 0:
+
+            deltaR = R[self.neighbor_points[0], :] - R[self.neighbor_points[1], :]
+            distance = torch.sqrt(((deltaR)**2).sum(dim=1))
+
+            dist = self.neighbor_mindist - distance + thre
+
+            indexl, l = self.barrier_function(dist, thre, 0, degree)
+
+            if len(indexl) > 0:
+                loss_distance += (l * weight_flatten[self.neighbor_points[0, indexl]] *
+                                  weight_flatten[self.neighbor_points[1, indexl]]).sum()
+                
+        return loss_distance

morphopt/optcore/updaters/geometry/objectivefuncs/shapederivative.py

@@ -0,0 +1,179 @@
+
+
+from scipy import interpolate
+import torch
+from .basefuncs import BaseConstraints
+import morphopt
+
+class ShapeDerivativeDisplacement(BaseConstraints):
+    """
+    Shape derivative for contact forces.
+    """
+
+    def __init__(self):
+
+        super().__init__()
+
+        self._r0: list[torch.Tensor] = []
+        """
+        Initial reference configuration.
+        """
+
+    def initialize(self, r0: list[torch.Tensor], *args, **kwargs):
+
+        objfun = morphopt.controller.objfun
+        fe = objfun.fe
+
+        self._r0 = [r0[i].detach().clone() for i in range(len(r0))]
+
+        ins = fe.assembly.get_instance('final_model')
+        part = fe.assembly.get_part('final_model')
+        grad_pos = torch.zeros_like(ins.nodes)
+
+        def closure_work(nodes_diff: torch.Tensor):
+            nodes0 = part.nodes
+            part.nodes = nodes_diff
+            fe.initialize()
+
+            # compute the sensitivity of the displacement
+            work = objfun.get_objective().to(part.nodes.device)
+            for i in range(len(objfun.U)):
+                GC0 = objfun.U[i].to(part.nodes.device)
+                fe.assembly.GC = GC0
+                fe.assembly.RGC = fe.assembly._GC2RGC(GC0)
+                morphopt.controller.params.feamodel.process_fea(fe=fe, step_index=i)
+                
+                R = fe.assembly.assemble_Stiffness_Matrix(GC=GC0)[0]
+                ADJu = objfun.ADJu[i].to(part.nodes.device)
+                work = work + (R*ADJu).sum()
+            part.nodes = nodes0
+            fe.initialize()
+            return work
+        grad_pos += torch.autograd.functional.jacobian(closure_work, part.nodes.detach().clone())
+
+        i=0
+
+        interpolate_points = self._get_interpolate_points()
+
+        self.sensitivity = self._sensitivity_interpolation(Ldot=grad_pos, points_request=part.nodes, interpolated_points=interpolate_points)
+
+    
+    def show_sensitivity(self, ind: int) -> None:
+        """
+        Show the shape sensitivity
+        """
+
+        import pyvista as pv
+        import numpy as np
+
+        plotter = pv.Plotter(window_size=(1000, 1000))
+        plotter.set_background('white')
+
+        r = self._r0[ind].detach().cpu().numpy()
+        n = self.sensitivity[ind].detach().cpu().numpy()
+
+        # r and n are [N, 3]
+        points = r
+        vectors = n
+        
+        # Debug: print statistics
+        print(f"Points shape: {points.shape}")
+        print(f"Vectors shape: {vectors.shape}")
+        print(f"Vector magnitude range: [{np.linalg.norm(vectors, axis=1).min():.6e}, {np.linalg.norm(vectors, axis=1).max():.6e}]")
+        
+        # Filter out zero vectors
+        vector_norms = np.linalg.norm(vectors, axis=1)
+        valid_mask = vector_norms > 1e-10
+        
+        if valid_mask.sum() == 0:
+            print("Warning: All sensitivity vectors are zero!")
+            return
+        
+        points_filtered = points[valid_mask]
+        vectors_filtered = vectors[valid_mask]
+        
+        # Auto-scale magnitude based on model size
+        model_size = np.max(points_filtered.max(axis=0) - points_filtered.min(axis=0))
+        vector_mag = np.linalg.norm(vectors_filtered, axis=1).mean()
+        mag_scale = model_size / vector_mag * 0.01  # Scale to 1% of model size
+        
+        print(f"Using {valid_mask.sum()} non-zero vectors out of {len(valid_mask)}")
+        print(f"Auto-scaled magnitude: {mag_scale:.6e}")
+        
+        # Add surface mesh for context
+        plotter.add_points(points_filtered, color='blue', point_size=5, render_points_as_spheres=True)
+        
+        # Add arrows with auto-scaled magnitude
+        plotter.add_arrows(points_filtered, vectors_filtered, mag=mag_scale, color='red')
+
+        plotter.show_axes()
+        plotter.show()
+
+    def __call__(self, r: list[torch.Tensor], *args, **kwargs):
+        loss_objective = 0.0
+
+        for i in range(len(self.sensitivity)):
+            # r[i], self._r0[i], self.sensitivity[i] are all [p, 3]
+            # Compute inner product: sum over all points and dimensions
+            loss_objective += ((r[i] - self._r0[i]) * self.sensitivity[i]).sum()
+
+        return loss_objective
+
+    def _get_interpolate_points(self, *args, **kwargs):
+        """
+        Get the interpolated points for the design variables.
+
+        Parameters:
+        *args: Additional arguments.
+        **kwargs: Additional keyword arguments.
+
+        Returns:
+            list[torch.Tensor]: The interpolated points for the design variables.
+        """
+        surfaces = morphopt.controller.params.geometry
+        r0 = surfaces.get_geometry_values()[0]
+        interpolated_points = []
+        for sf in range(surfaces.num_surface):
+            interpolated_points.append(r0[sf].cpu().numpy())
+        return interpolated_points
+    
+    def _sensitivity_interpolation(
+            self, Ldot: torch.Tensor, points_request: torch.Tensor,
+            interpolated_points: list[torch.Tensor]) -> list[torch.Tensor]:
+        """
+        Interpolate the sensitivity into the structural grids.
+        
+        Parameters:
+            Ldot (torch.Tensor): The sensitivity values for elements gaussian points.
+                [num_points, 3]
+            points_request (torch.Tensor): The coordinates of the elements.
+                [num_points, 3]
+            interpolated_points (list[torch.Tensor]): The coordinates of the interpolation points.
+                [num_surface, 3]
+                
+        Returns:
+            list[torch.Tensor]: The interpolated sensitivity values for the structural grids.
+                [num_surface, sensitivity]
+        """
+
+        # interpolate the sensitivity into the structral grids
+        output_senNodes = []
+
+        for surf_index in range(len(interpolated_points)):
+
+            output_senNodes.append(torch.zeros(interpolated_points[surf_index].shape))
+
+            for i in range(3):
+                Part_B = interpolate.griddata(
+                    points_request.reshape([-1, 3]).detach().cpu().numpy(),
+                    Ldot[:, i].flatten().detach().cpu().numpy(),
+                    (interpolated_points[surf_index][:, 0],
+                    interpolated_points[surf_index][:, 1],
+                    interpolated_points[surf_index][:, 2]),
+                    method='nearest',
+                    fill_value=0,
+                    rescale=True)
+
+                output_senNodes[-1][:, i] = torch.tensor((Part_B).tolist())
+
+        return output_senNodes

morphopt/optcore/updaters/geometry/objectivefuncs/surfacefairness.py

@@ -0,0 +1,40 @@
+import torch
+from .basefuncs import BaseConstraints
+from ....modelparams import GeometryParams
+from . import ShapeDerivativeDisplacement
+class Fairness(BaseConstraints):
+    """
+    Fairness objective function for MorphOpt.
+    """
+
+    def __init__(self, surfaces: GeometryParams, sensitivity: ShapeDerivativeDisplacement):
+        """
+        Initialize the fairness objective function with a name.
+        """
+        super().__init__()
+        self.surfaces = surfaces
+        """
+        The surfaces object that contains the design variables.
+        """
+
+        self.sensitivity = sensitivity
+        """the sensitivity to anchor the scaler"""
+
+    def __call__(self, r: list[torch.Tensor], rdu: list[torch.Tensor], rdu2: list[torch.Tensor], *args, **kwargs) -> float:
+        """
+        Call the fairness objective function.
+
+        Args:
+            r (list[torch.Tensor]): The point coordinates of the surfaces.
+            rdu (list[torch.Tensor]): The partial derivatives of the surfaces.
+            rdu2 (list[torch.Tensor]): The second partial derivatives of the surfaces.
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            The value of the fairness objective function.
+        """
+
+
+        # Implement the fairness objective function here
+        return sum(self.surfaces.get_penalty_fairness(self.scaler, r, rdu, rdu2))