morphopt 3.1.1__py3-none-any.whl

morphopt/optcore/modelparams/materials/__init__.py

@@ -0,0 +1 @@
+from .materialparams import Materials

morphopt/optcore/modelparams/materials/materialparams.py

@@ -0,0 +1,110 @@
+import torch
+from torch._refs import to
+
+import torchfea
+from ..base_params import BaseParams
+
+class Materials(BaseParams):
+    """
+    Class to handle the materials of the morphable model.
+    """
+
+    def __init__(self, mu: float, kappa: float, density: float) -> None:
+        """
+        Initialize the Materials class.
+
+        Args:
+            mu (float): The shear modulus of the material.
+            kappa (float): The bulk modulus of the material.
+        """
+        super().__init__()
+        self._mu: float
+        self._kappa: float
+        self._density: float
+
+        self.mu = mu
+        self.kappa = kappa
+        self.density = density
+
+    @property
+    def mu(self) -> float:
+        """
+        Get the shear modulus.
+
+        Returns:
+            float: The shear modulus.
+        """
+        return self._mu
+    
+    @mu.setter
+    def mu(self, value: float) -> None:
+        """
+        Set the shear modulus.
+
+        Args:
+            value (float): The new shear modulus.
+        """
+        self._mu = float(value)
+
+    @property
+    def kappa(self) -> float:
+        """
+        Get the bulk modulus.
+
+        Returns:
+            float: The bulk modulus.
+        """
+        return self._kappa
+    
+    @kappa.setter
+    def kappa(self, value: float) -> None:
+        """
+        Set the bulk modulus.
+
+        Args:
+            value (float): The new bulk modulus.
+        """
+        self._kappa = float(value)
+
+    @property
+    def density(self) -> float:
+        """
+        Get the density.
+
+        Returns:
+            float: The density.
+        """
+        return self._density
+    
+    @density.setter
+    def density(self, value: float) -> None:
+        """
+        Set the density.
+
+        Args:
+            value (float): The new density.
+        """
+        self._density = float(value)
+
+    def get_ratio(self, nodes: torch.Tensor) -> float:
+        """
+        Get the ratio of maximum to minimum modulus.
+        
+        Returns:
+            float: The ratio of maximum to minimum modulus.
+        """
+        return 1.0
+
+    def set_materials(self, fe: torchfea.FEAController) -> None:
+        """
+        Set the materials of the FEA model.
+
+        Args:
+            fe (torchfea.FEAController): The FEA controller.
+        """
+        elements = fe.assembly.get_part('final_model').elems['element-0']
+        mu = self.mu
+        kappa = self.kappa
+        materials = torchfea.materials.NeoHookean(mu=mu, kappa=kappa)
+        elements.set_materials(materials)
+        elements.density = self.density

morphopt/optcore/modelparams/params.py

@@ -0,0 +1,88 @@
+
+from ..baseobject import BaseObject
+from .feamodel.feaparams import FEAParams
+from .geometry.geometryparams import GeometryParams
+from .materials.materialparams import Materials
+class Params(BaseObject):
+    """
+    Class to handle the parameters of the model.
+    """
+    def __init__(self, surfaces: GeometryParams, feamodel: FEAParams, materials: Materials) -> None:
+        """
+        Initialize the Params class.
+        """
+        self.geometry = surfaces
+        """
+        Surfaces: An instance of the Surfaces class from the ModelParams module.
+        """
+        self.feamodel = feamodel
+        """
+        Loads: An instance of the Loads class from the ModelParams module.
+        """
+        self.materials = materials
+        """
+        Materials: An instance of the Materials class from the ModelParams module.
+        """
+
+    def reinitialize(self, iteration: int) -> None:
+        """
+        reInitialize the parameters.
+        """
+        self.geometry.reinitialize(iteration=iteration)
+        self.feamodel.reinitialize(iteration=iteration)
+        self.materials.reinitialize(iteration=iteration)
+
+    def initialize(self):
+        """
+        Initialize the parameters.
+        """
+        self.geometry.initialize()
+        self.feamodel.initialize()
+        self.materials.initialize()
+        
+
+    def save(self, foldpath: str, iteration: int) -> None:
+        """
+        Save the parameters to a file.
+        
+        Args:
+            foldpath (str): The path to save the parameters.
+        """
+        self.geometry.save(foldpath=foldpath, iteration=iteration)
+        self.feamodel.save(foldpath=foldpath, iteration=iteration)
+        self.materials.save(foldpath=foldpath, iteration=iteration)
+
+    def load(self, foldpath: str, iteration: int) -> None:
+        """
+        Load the parameters from a file.
+        
+        Args:
+            foldpath (str): The path to load the parameters from.
+        """
+        self.geometry.load(foldpath=foldpath, iteration=iteration)
+        # self.feamodel.load(foldpath=foldpath, iteration=iteration)
+        # self.materials.load(foldpath=foldpath, iteration=iteration)
+
+    def export_data(self, filepath: str):
+        """
+        Export the data of parameters to file(s).
+        
+        Args:
+            filepath (str): The path to export the data.
+        """
+        self.geometry._export_data(filepath=filepath)
+        self.feamodel._export_data(foldpath=filepath)
+        self.materials._export_data(foldpath=filepath)
+
+    def pathlog_required(self) -> list[str]:
+        """
+        Allocate the path for saving data.
+        
+        Args:
+            foldpath (str): The path to allocate.
+        """
+        paths = []
+        paths += self.geometry.pathlog_required()
+        paths += self.feamodel.pathlog_required()
+        paths += self.materials.pathlog_required()
+        return paths

morphopt/optcore/objfunc.py

@@ -0,0 +1,248 @@
+import math
+import torchfea
+import numpy as np
+import torch
+import scipy.sparse as sp
+import pypardiso
+import morphopt
+
+from .baseobject import BaseObject
+
+class ObjectiveFunction(BaseObject):
+    """
+    The objective functions in morphopt.
+    """
+
+    def __init__(self):
+        self.fe: torchfea.FEAController = None
+        """
+        The FEA solver instance.
+        """
+
+        self.inp: torchfea.FEA_INP = None
+        """
+        The FEA .inp file.
+        """
+        
+        self.U: torch.Tensor
+        """
+        The displacement field.
+        [shape: (num_tasks, num_dofs)]
+        """
+
+        self.ADJu: torch.Tensor
+        """
+        The first adjoint displacement field.
+        [shape: (num_tasks, num_dofs)]
+        """
+
+        self.K_sp: list[sp.csr_matrix]
+        """
+        The sparse stiffness matrices.
+        [shape: (num_tasks,)]
+        """
+
+        self.K_solver: list[pypardiso.PyPardisoSolver]
+        """
+        The solvers for the stiffness matrix.
+        [shape: (num_tasks,)]
+        """
+
+    def get_objective(self, *args, **kwargs) -> torch.Tensor:
+        """
+        Get the value of the objective function.
+
+        Args:
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            torch.Tensor: The value of the objective function.
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+
+    def get_metrics(self) -> list[float]:
+        """
+        Get custom metrics for display.
+        
+        Returns:
+            list[float]: A list of metric values.
+        """
+        return []
+
+    @property
+    def num_tasks(self) -> int:
+        """
+        Get the number of tasks.
+        """
+        return self.U.shape[0]
+    
+    def pathlog_required(self):
+        return ['deformation']
+
+    def calculate_adjoint(self, *args, **kwargs) -> torch.Tensor:
+        """
+        Calculate the adjoint variables.
+        """
+        raise NotImplementedError("This method should be overridden by subclasses.")
+    
+    def calculate_adjoint_problem(self, *args, **kwargs) -> torch.Tensor:
+        """
+        Calculate the linear factor of the objective function.
+        """
+
+        def closure_JdU(U: torch.Tensor) -> torch.Tensor:
+            U0 = self.U
+            self.U = U
+            obj = self.get_objective()
+            self.U = U0
+            return obj
+        
+        ADJFu_now: torch.Tensor = -torch.autograd.functional.jacobian(closure_JdU, self.U.detach().clone())
+
+        ADJu = []
+        K_sp_list = []
+        K_solver_list = []
+        for step_index in range(self.num_tasks):
+
+            # set the loads
+            morphopt.controller.params.feamodel.process_fea(fe=self.fe, step_index=step_index)
+            
+            # region get the decomposed stiffness matrix
+            R, K_indices, K_values = self.fe.assembly.assemble_Stiffness_Matrix(GC=self.U[step_index].to(self.fe.assembly.device))
+            K_values = K_values.cpu().numpy()
+            K_indices = K_indices.cpu().numpy()
+            K_sp = sp.coo_matrix(
+                (K_values,
+                (K_indices[0], K_indices[1])), dtype=np.float64,
+                shape=(self.fe.assembly.GC.shape[0], self.fe.assembly.GC.shape[0])).tocsr()
+            K_solver = pypardiso.PyPardisoSolver()
+            K_solver.factorize(K_sp)
+
+            K_sp_list.append(K_sp)
+            K_solver_list.append(K_solver)
+
+            # endregion
+
+            # region calculate the adjoint variable
+            
+            ADJu_now = torch.from_numpy(K_solver.solve(K_sp, ADJFu_now[step_index].cpu().numpy())).cpu()
+            ADJu.append(ADJu_now)
+            # endregion
+
+        self.ADJu = torch.stack(ADJu, dim=0).cpu()
+        self.K_sp = K_sp_list
+        self.K_solver = K_solver_list
+
+    def __str__(self) -> str:
+
+        result = ["FE_result Summary:"]
+        
+        for i in range(self.num_tasks):
+            result.append(f"=================================Task {i+1}=================================")
+            
+            
+            # 格式化位移向量（一维）
+            u_vector = self.U[i][-6:].tolist()
+            u_str = " ".join([f"{x:.6f}" for x in u_vector])
+            result.append(f"  Displacement U: {u_str}")
+            
+            # # 格式化Jacobian矩阵（二维）
+            # if self.Udp is not None:
+            #     matrix = self.Udp[i][:, -6:].T.tolist()  # 二维矩阵
+            #     result.append(f"  Jacobian Udp:")
+            #     # 格式化并添加矩阵每行
+            #     formatted = format_matrix(matrix, indent=4)
+            #     result.extend(formatted)
+            
+            # # 格式化UdF矩阵（二维）
+            # if self.UdF is not None:
+            #     matrix = self.UdF[i][:, -6:].tolist()  # 二维矩阵
+            #     result.append(f"  UdF:")
+            #     formatted = format_matrix(matrix, indent=4)
+            #     result.extend(formatted)
+
+            result.append(f"============================================================================")
+        
+        return "\n".join(result)
+        
+    def __getitem__(self, key):
+        """
+        Get the attribute with the given key.
+        
+        Parameters:
+            key: The key of the attribute to get.
+            
+        Returns:
+            The attribute value.
+            
+        Raises:
+            KeyError: If the key is not found.
+        """
+        if hasattr(self, key):
+            return getattr(self, key)
+        else:
+            raise KeyError(f"'{key}' not found in FE_result")
+
+    def save(self, foldpath: str, iteration: int, insname: str = 'final_model', surface: str = 'surface_0_All') -> None:
+        """
+        Save the figures of the FEA results.
+
+        Parameters:
+            foldpath (str): The path to save the figures.
+            iteration (int): The current iteration number.
+        """
+        ins = self.fe.assembly.get_instance(insname)
+        surfaces = [surface]
+        surface_elements: list[torchfea.elements.BaseSurface] = []
+        for i in range(len(surfaces)):
+            surface_elements = surface_elements + ins.surfaces.get_elements(surfaces[i])
+        
+        surface_connections = [surface_elements[i].surf_elems_circ.cpu().numpy() for i in range(len(surface_elements))]
+
+        for case in range(self.num_tasks):
+            deformed_nodes = (ins.nodes + self.fe.assembly._GC2RGC(self.U[case].to(ins.nodes.device))[ins._RGC_index]).detach().cpu().numpy()
+
+            import pyvista as pv
+
+            plotter = pv.Plotter(off_screen=True, window_size=(1200, 1200))
+
+            # Create faces list for pyvista
+            faces = []
+            for connection in surface_connections:
+                for face in connection:
+                    if -1 not in face:
+                        faces.append([len(face)] + list(face))
+
+            # Create pyvista mesh
+            mesh = pv.PolyData(deformed_nodes, faces)
+            plotter.add_mesh(mesh, color=(40.0/255, 120.0/255, 181.0/255), opacity=1.0)
+
+            x_min, x_max = deformed_nodes[:,0].min().item(), deformed_nodes[:,0].max().item()
+            y_min, y_max = deformed_nodes[:,1].min().item(), deformed_nodes[:,1].max().item()
+            z_min, z_max = deformed_nodes[:,2].min().item(), deformed_nodes[:,2].max().item()
+
+            # Add some padding to the bounds
+            padding = 0.05 * max(x_max-x_min, y_max-y_min, z_max-z_min)
+            
+            plotter.show_bounds(xtitle='X', ytitle='Y', ztitle='Z', color='black',
+                                bounds=[x_min-padding, x_max+padding, 
+                                        y_min-padding, y_max+padding, 
+                                        z_min-padding, z_max+padding])
+            
+            # Approximate view
+            plotter.set_background('white')
+            plotter.enable_parallel_projection()
+            azimuth = 210
+            elevation = 20
+            plotter.view_vector((math.cos(math.radians(azimuth)) * math.cos(math.radians(elevation)),
+                math.sin(math.radians(azimuth)) * math.cos(math.radians(elevation)),
+                math.sin(math.radians(elevation))))
+
+            # Save the figure as a PNG file
+            plotter.screenshot(f"{foldpath}/{self.pathlog_required()[0]}/task_{case}_iter_{iteration}.png")
+
+            # Save the deformed mesh as an OBJ file
+            obj_filepath = f"{foldpath}/{self.pathlog_required()[0]}/task_{case}_iter_{iteration}.obj"
+            mesh.save(obj_filepath)
+            plotter.close()

morphopt/optcore/solver.py

@@ -0,0 +1,159 @@
+
+import numpy as np
+import torch
+import copy
+import torchfea
+import multiprocessing as mp
+
+from .modelparams import Params, FEAParams, Materials
+
+from .baseobject import BaseObject
+import morphopt
+class MorphSolver(BaseObject):
+    """
+    This class is responsible for solving the FEA and get the displacement of the soft robot.
+    """
+
+    
+    def __init__(self, params: Params, num_process: int = 4, available_gpus: list[str] = None, task_index_list: list[list[int]] = None):
+        """
+        Initialize the Solver class with a list of pressure values.
+
+        Parameters:
+            params (Params): 
+            num_process (int): The number of processes to use for parallel computation.
+        """
+
+        super().__init__()
+
+        self.params: Params = params
+        """
+        Pressures: An instance of the params of the optimization problem.
+        """
+
+        self.num_process = num_process
+        """
+        int: The number of processes to use for parallel computation.
+        """
+
+        if available_gpus is None:
+            self.available_gpus = ['cuda:%d' % i for i in range(torch.cuda.device_count())]
+        else:
+            self.available_gpus = available_gpus
+
+        self.task_index_list = task_index_list
+        """
+        list[list[int]]: A list of task indices for each process.
+        """
+
+    def initialize(self):
+        if self.task_index_list is None:
+            self.task_index_list = []
+            for i in range(morphopt.controller.params.feamodel.num_load_steps):
+                self.task_index_list.append([i])
+
+        
+
+    def reinitialize(self, iteration: int) -> None:
+        """
+        Reinitialize the solver for a new iteration.
+
+        Parameters:
+            iteration (int): The current iteration number.
+        """
+        pass
+
+    def solve(self):
+        """
+        Solve the optimization problem using the specified solver.
+
+        Returns:
+            tuple: the displacement field and its derivatives:
+                - fe (torchfea.FEAController): An instance of the FEA_Main class with the given input parameters.
+                - GC0 (list[torch.Tensor]): The displacement field at the reference point.
+                - Udp0 (list[torch.Tensor]): The displacement field at the reference point with respect to the pressure.
+                - GCv (list[torch.Tensor]): The first adjoint displacement field.
+                - GCw (list[torch.Tensor]): The second adjoint displacement field.
+        """
+
+        # multiprocess FEA
+
+        fe_cpu = copy.deepcopy(morphopt.controller.objfun.fe)
+        fe_cpu.change_device(torch.device('cpu'))
+
+        # self._solve_FEA(fe=fe_cpu, 
+        #                 feamodel=self.params.feamodel,
+        #                 task_index=self.task_index_list[0],
+        #                 available_gpus=self.available_gpus)
+
+        pools = morphopt.controller.pools
+        result = []
+        for i in range(len(self.task_index_list)):
+            result.append(
+                            pools.apply_async(self._solve_FEA,
+                                            kwds={'fe': fe_cpu,
+                                                    'feamodel': self.params.feamodel,
+                                                    'task_index': self.task_index_list[i],
+                                                    'available_gpus': self.available_gpus}))
+
+        # get the result
+        U0 = []
+        list_number = []
+        for i in range(len(result)):
+            U0 += result[i].get()
+            list_number += self.task_index_list[i]
+        list_number = np.array(list_number).flatten()
+        
+        Uresult = torch.tensor(U0).to(torch.float64)[list_number]
+        del fe_cpu
+        return Uresult
+        
+
+    @classmethod
+    def _solve_FEA(cls, fe: torchfea.FEAController, 
+                   feamodel: FEAParams, 
+                   task_index: list[int], 
+                   available_gpus: list[str], 
+                   U_guess: np.ndarray = None):
+        import os
+        os.environ['KMP_DUPLICATE_LIB_OK']='True'
+        import sys
+        import torch
+        sys.path.append(os.getcwd())
+ 
+        current_process_name = mp.current_process().name
+        try:
+            pool_id = int(current_process_name[-1])
+        except:
+            pool_id = 0
+
+        if len(available_gpus) > 0:
+            cuda_now = (pool_id+1) % len(available_gpus)
+            torch.set_default_device(available_gpus[cuda_now])
+            device_now = available_gpus[cuda_now]
+            print("Process %s use GPU: %s" % (current_process_name, available_gpus[cuda_now]))
+        else:
+            torch.set_default_device('cpu')
+            device_now = 'cpu'
+            print("Process %s use CPU" % (current_process_name))
+
+        # torch.set_default_device(torch.device('cuda:0'))
+        torch.set_default_dtype(torch.float64)
+        torch.cuda.empty_cache()
+        # construct the FEA
+        fe.change_device(device_now)
+
+        if U_guess is not None:
+            U0 = torch.from_numpy(U_guess).to(torch.float64).to(fe.assembly.device)
+        else:
+            U0 = fe.assembly.GC.to(torch.get_default_device())
+
+        result_list = []
+        for i in range(len(task_index)):
+            feamodel.process_fea(fe=fe, step_index=task_index[i])
+            result: torchfea.solver.StaticResult = fe.solve(GC0=U0.to(torch.get_default_device()), if_initialize=False)
+
+            U0 = result.GC.detach()
+            Unow = U0.cpu().numpy()
+            result_list.append(Unow)
+        return result_list

morphopt/optcore/updaters/__init__.py

@@ -0,0 +1,2 @@
+from . import geometry
+from .updaters import Updaters