morphopt 3.1.1__py3-none-any.whl

morphopt/__init__.py

@@ -0,0 +1,32 @@
+# region optcore imports
+from .optcore.controller import Controller
+from .optcore.modelparams import GeometryParams, FEAParams, Materials
+from .optcore.solver import MorphSolver
+from .optcore.updaters.geometry import UpdaterGeometries
+from .optcore.updaters.updaters import Updaters
+from .optcore.modelparams import Params
+from .optcore.objfunc import ObjectiveFunction
+from .optcore.history import History
+from .optcore.baseobject import BaseObject
+from .optcore.utils.plot_history_surface import SurfacesFigurePlotter
+# endregion
+
+from .opt_runner import start_optimization, debug_optimization, view_optimization_result
+
+
+
+
+controller: Controller = None
+
+__all__ = [
+    "Controller",
+    "GeometryParams",
+    "FEAParams",
+    "Materials",
+    "MorphSolver",
+    "UpdaterGeometries",
+    "Updaters",
+    "Params",
+    "ObjectiveFunction",
+]
+

morphopt/opt_runner.py

@@ -0,0 +1,130 @@
+
+
+
+def start_optimization(device='cpu', restart_per_iteration: int = 20, path_result: str=None, target_iteration=None, no_gui: bool=False):
+    """
+    Start a new optimization process.
+
+    Args:
+        Controller (type): The controller class to use for the optimization.
+        device (str, optional): The device to use for computation. Defaults to 'cpu'.
+        restart_per_iteration (int, optional): The number of iterations between restarts. Defaults to 20.
+    """
+    if path_result is None:
+        import __main__
+        main_filepath = __main__.__file__
+    else:
+        main_filepath = path_result + '/scripts/' + 'MAIN_SCRIPT_FOR_RESTART.py'
+
+    import time
+    import multiprocessing as mp
+    from .taskoptmization import TaskOptimization
+    from .taskui import run_ui
+
+
+    dataqueue = mp.Queue()
+    process_optimization = mp.Process(target=TaskOptimization.task_optimization, kwargs={'path_result': path_result, 
+                                                                                'main_filepath': main_filepath,
+                                                                                'device': device, 
+                                                                                'target_iteration': target_iteration,
+                                                                                'restart_per_iteration': restart_per_iteration, 
+                                                                                'dataqueue': dataqueue})
+    process_optimization.start()
+
+    if no_gui:
+        process_optimization.join()
+        return
+    
+    process_ui = mp.Process(target=run_ui, args=(dataqueue, main_filepath))
+    process_ui.start()
+
+    process_optimization.join()
+    process_ui.join()
+
+def view_optimization_result(path_result: str = None):
+    """
+    View the result of an optimization process.
+
+    Args:
+        path_result (str): The folder path of the optimization result.
+    """
+    import os
+    import multiprocessing as mp
+    from .taskui import run_ui
+    from .optcore.history import History
+
+    if path_result is None or not os.path.exists(path_result):
+        # Use file dialog to select directory if path is not provided
+        # We need a temporary app to show the dialog
+        from PyQt6.QtWidgets import QApplication, QFileDialog
+        import sys
+        
+        # Check if an app instance already exists
+        app = QApplication.instance()
+        if not app:
+            app = QApplication(sys.argv)
+        
+        path_result = QFileDialog.getExistingDirectory(None, "Select Optimization Result Folder", os.getcwd())
+        if not path_result:
+            return
+
+    main_filepath = os.path.join(path_result, 'scripts', 'MAIN_SCRIPT_FOR_RESTART.py')
+    if not os.path.exists(main_filepath):
+        print(f"Error: {main_filepath} not found.")
+        return
+
+    # Determine the last iteration
+    history = History()
+    try:
+        history.load(foldpath=os.path.join(path_result, 'log'))
+        last_iteration = history.iteration
+    except:
+        last_iteration = 0
+
+    dataqueue = mp.Queue()
+    # Send the initial data to load the result
+    dataqueue.put({'iteration': last_iteration, 'path_result': path_result})
+
+    run_ui(dataqueue, main_filepath)
+
+def debug_optimization(device='cpu', restart_per_iteration: int = 20, path_result: str=None, target_iteration=None, ):
+    """
+    Start a new optimization process.
+
+    Args:
+        Controller (type): The controller class to use for the optimization.
+        device (str, optional): The device to use for computation. Defaults to 'cpu'.
+        restart_per_iteration (int, optional): The number of iterations between restarts. Defaults to 20.
+    """
+    import __main__
+    from .taskoptmization import TaskOptimization
+    import os
+    import morphopt
+
+    if path_result is None:
+        import __main__
+        main_filepath = __main__.__file__
+    else:
+        main_filepath = path_result + '/scripts/' + 'MAIN_SCRIPT_FOR_RESTART.py'
+
+    filename = os.path.splitext(os.path.basename(main_filepath))[0] 
+    filepath = os.path.dirname(main_filepath)
+    os.chdir(filepath)
+    import sys
+    sys.path.append(os.getcwd())
+
+    Controller: morphopt.Controller = getattr(__import__(filename), 'ThisController')
+
+    controller: morphopt.Controller = Controller()
+    controller.restart_per_iteration = restart_per_iteration
+    controller.optdevice = device
+
+    TaskOptimization.optmain(device=device, 
+                            path_result=path_result,
+                            target_iteration=target_iteration,
+                            restart_per_iteration=restart_per_iteration,
+                            main_filepath=main_filepath)
+
+
+
+

morphopt/optcore/baseobject.py

@@ -0,0 +1,48 @@
+
+
+class BaseObject:
+
+    def initialize(self, *args, **kwargs) -> None:
+        """
+        Initialize the class.
+        
+        This method should be implemented in subclasses to initialize specific attributes.
+        """
+        pass
+
+    def reinitialize(self, iteration: int, *args, **kwargs) -> None:
+        """
+        reInitialize the class.
+        
+        This method should be implemented in subclasses to reinitialize specific attributes.
+        """
+        pass
+
+    def save(self, foldpath: str, iteration: int) -> None:
+        """
+        Save the objective function data to a file.
+        
+        Args:
+            foldpath (str): The path to save the objective function data.
+            iteration (int): The iteration number to save.
+        """
+        pass
+
+    def load(self, foldpath: str, iteration: int) -> None:
+        """
+        Load the objective function data from a file.
+        
+        Args:
+            foldpath (str): The path to load the objective function data from.
+            iteration (int): The iteration number to load.
+        """
+        pass
+    
+    def pathlog_required(self) -> list[str]:
+        """
+        Allocate the path for saving data.
+        
+        Args:
+            foldpath (str): The path to allocate.
+        """
+        return []

morphopt/optcore/controller.py

@@ -0,0 +1,404 @@
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .. import Params, MorphSolver, Updaters, ObjectiveFunction
+from .history import History
+import datetime
+import importlib
+import os
+import shutil
+import torch
+import numpy as np
+
+import time
+import gc
+import morphopt
+import multiprocessing as mp
+
+class Controller:
+
+    class Params:
+        pass
+
+    class Solver:
+        pass
+
+    class Updater:
+        pass
+
+    class ObjectiveFunction:
+        pass
+
+    def __init__(self, path_result_folder: str, opt_label: str = 'DefaultLabel') -> None:
+        """
+        Initialize the Controller class.
+
+        This class is responsible for managing the optimization process.
+        It initializes the workflow, generates the model, performs finite element analysis (FEA), and updates the surfaces.
+        """
+
+        self.params: Params 
+        """
+        Params: An instance of the Params class from the ModelParams module.
+        """
+
+        self.solver: MorphSolver
+        """
+        Solver: An instance of the Solver class from the Solve module.
+        """
+
+        self.updater: Updaters
+        """
+        Updaters: An instance of the Updaters class from the Update module.
+        """
+
+        self.objfun: ObjectiveFunction
+        """
+        ObjFun: An instance of the ObjectiveFunction class from the ObjFunc module.
+        """
+
+        self.opt_label: str = opt_label
+        """
+        The name of the optimization.
+        """
+
+        self.path_result_folder: str = path_result_folder
+        """
+        The foldpath to the result directory.
+        """
+
+        self.path_result: str = None
+        """
+        The path to the result directory.
+        """
+
+        self.history = History()
+        """
+        History: An instance of the History class from the History module to record the optimization history.
+        """
+
+        self.restart_per_iteration: int = 20
+        """
+        The frequency of restarting the optimization process.
+        """
+
+        self.dataqueue: Optional[mp.Queue] = None
+
+        self.pools = None
+        """
+        The multiprocessing pool for parallel computation.
+        """
+
+        self.optdevice: str = 'cpu'
+        """
+        The device to run the optimization on.
+        """
+
+    def initialize_path(self, main_filepath: str = None) -> None:
+        """
+        Initialize the workflow by importing necessary modules and setting up the environment.
+        """
+
+        def vendor_package(package_name, target_dir='.'):
+            """
+            copy the specified package to the target directory.
+            
+            Args:
+                package_name: The name of the package to copy.
+                target_dir: The target directory, default is the current directory.
+            """
+            try:
+                # import the package
+                module = importlib.import_module(package_name)
+                
+                # get the package path
+                package_path = os.path.dirname(module.__file__)
+                
+                # construct the target path
+                target_path = os.path.join(target_dir, package_name)
+                
+                # if the target directory exists, remove it first
+                if os.path.exists(target_path):
+                    if os.path.isfile(target_path):
+                        os.remove(target_path)
+                    else:
+                        shutil.rmtree(target_path)
+                
+                # copy the package files
+                if os.path.isdir(package_path):
+                    shutil.copytree(package_path, target_path)
+                    print(f"successfully copied package '{package_name}' to {target_path}")
+                else:
+                    shutil.copy2(package_path, target_path)
+                    print(f"successfully copied module '{package_name}' to {target_path}")
+                    
+                # Check if there are related .pth files or other metadata that need to be handled
+                # For pure Python packages, the above steps are usually sufficient
+                
+            except ImportError:
+                print(f"Error: Package '{package_name}' not found. Please install it first.")
+            except Exception as e:
+                print(f"Error occurred during copying: {str(e)}")
+        
+        self.path_result = self.path_result_folder + '/' + self.opt_label + '_' + 'T' + datetime.datetime.now().strftime(
+            "%Y%m%d_%H%M%S") + '/'
+            
+        # create the result path if it does not exist
+        os.makedirs(self.path_result + '/cache/')
+        pathlog_list = []
+        pathlog_list += self.params.pathlog_required()
+        pathlog_list += self.solver.pathlog_required()
+        pathlog_list += self.updater.pathlog_required()
+        pathlog_list += self.objfun.pathlog_required()
+        for pathlog in pathlog_list:
+            os.makedirs(self.path_result + '/log/' + pathlog)
+
+        os.makedirs(self.path_result + '/fea')
+
+        os.makedirs(self.path_result + '/scripts/', exist_ok=True)
+        if main_filepath is not None:
+            shutil.copy(main_filepath, self.path_result + '/scripts/MAIN_SCRIPT_FOR_RESTART.py')
+        else:
+            import __main__
+            shutil.copy(__main__.__file__, self.path_result + '/scripts/MAIN_SCRIPT_FOR_RESTART.py')
+
+        vendor_package('torchfea', target_dir=self.path_result + '/scripts/')
+        vendor_package('cpgeo', target_dir=self.path_result + '/scripts/')
+        vendor_package('morphopt', target_dir=self.path_result + '/scripts/')
+
+
+    def initialize(self) -> None:
+        """
+        Initialize the workflow by initializing the Params, Solver, Updaters, and ObjFun classes.
+        """
+        morphopt.controller = self
+
+        self.params = self.Params()
+        self.solver = self.Solver(params=self.params)
+        self.updater = self.Updater(params=self.params)
+        self.objfun = self.ObjectiveFunction()
+
+
+        self.params.initialize()
+        self.solver.initialize()
+        self.updater.initialize()
+        self.objfun.initialize()
+        self.history.initialize()
+
+        self.pools = mp.Pool(processes=self.solver.num_process)
+
+    def start_optimization(self, main_filepath: str = None) -> None:
+        
+        self.initialize()
+        self.initialize_path(main_filepath=main_filepath)
+        self.opt_loop()
+
+    def restart_optimization(self, path_result: str, target_iteration: int = None) -> None:
+
+        self.path_result = path_result
+        self.initialize()
+        self.history.load(foldpath=self.path_result + '/log/', iteration=target_iteration)
+
+        if target_iteration is None:
+            target_iteration = self.history.iteration
+
+        self.params.load(foldpath=self.path_result + '/log/', iteration=target_iteration)
+        self.solver.load(foldpath=self.path_result + '/log/', iteration=target_iteration)
+        self.updater.load(foldpath=self.path_result + '/log/', iteration=target_iteration)
+
+        self.history.iteration += 1
+
+        self.opt_loop()
+
+    def opt_loop(self) -> None:
+        """
+        This function runs the optimization loop for a specified number of iterations.
+        It calls the opt_step function in each iteration.
+        """
+        
+        while True:
+
+            # Explicitly release large objects to ensure they are collected
+            self.clear_cache()
+
+            seed_size0 = self.params.geometry.fea_seed_size
+            # self.params.geometry.fea_seed_size = seed_size0 * np.random.uniform(0.9, 1.0)
+
+            loss, t0, t1, t2, t3 = self.step()
+            
+            self.params.geometry.fea_seed_size = seed_size0
+
+            # Record the history of the optimization process
+            self.record_history(loss, t0, t1, t2, t3)
+            
+            # Print the information
+            self.print_info(t0, t1, t2, t3)
+
+            # Save the current parameters and plot the figures
+            self.save()
+
+            # if dataqueue is not None, send the data to the queue
+            if self.dataqueue is not None:
+                self.dataqueue.put({'iteration': self.history.iteration, 'path_result': self.path_result})
+            
+            if self.restart_per_iteration > 0 and (self.history.iteration+1) % self.restart_per_iteration == 0:
+                self.pools.close()
+                self.pools.join()
+                return
+            
+            self.history.iteration += 1
+            
+
+    def step(self):
+        """
+        Perform a single optimization step.
+        Returns:
+            loss (torch.Tensor): The loss value after the optimization step.
+            t0 (float): The start time of the optimization step.
+            t1 (float): The time after model generation.
+            t2 (float): The time after finite element analysis (FEA).
+            t3 (float): The time after updating the surfaces.
+        """
+        t0 = time.time()
+        if os.path.exists(self.path_result + '/cache/TopOptRun.inp'):
+            os.remove(self.path_result + '/cache/TopOptRun.inp')
+
+        # Initialize the workflow
+        self.params.reinitialize(iteration = self.history.iteration)
+        self.solver.reinitialize(iteration = self.history.iteration)
+        self.updater.reinitialize(iteration = self.history.iteration)
+        self.objfun.reinitialize(iteration = self.history.iteration)
+
+        # Perform the optimization step
+        # Generate the model
+        inp = self.params.geometry.generate()
+        self.objfun.inp = inp
+        fe = self.params.feamodel.create_fea(inp=inp)
+        self.params.materials.set_materials(fe)
+        fe.initialize()
+        self.objfun.fe = fe
+
+        t1 = time.time()
+
+        # Perform finite element analysis (FEA)
+        self.objfun.U = self.solver.solve()
+
+        t2 = time.time()
+
+        # the adjoint problem
+        self.objfun.calculate_adjoint_problem()
+
+        # Update the surfaces based on the FEA results
+        self.updater.update()
+        self.updater.update_variables()
+
+        loss = self.objfun.get_objective()
+
+        t3 = time.time()
+
+        return loss, t0, t1, t2, t3
+
+    def record_history(self, loss: torch.Tensor, t0: float, t1: float, t2: float, t3: float) -> None:
+        """
+        Record the history of the optimization process.
+        """
+        if self.objfun.fe.assembly._reference_points.get('RP_head') is None:
+            displacement = []
+        else:
+            GC_start_index = self.objfun.fe.assembly._GC_list_indexStart[self.objfun.fe.assembly.get_reference_point('RP_head')._RGC_index]
+            displacement = [self.objfun.U[i][GC_start_index:GC_start_index+6].tolist() for i in range(len(self.objfun.U))]
+        self.history.append('deformation', displacement)
+        self.history.append('objective', loss.item())
+        self.history.append('metrics', self.objfun.get_metrics())
+        self.history.append('time', [t1-t0, t2-t1, t3-t2])
+        self.history.append('num_elements', self.objfun.fe.assembly.get_instance('final_model').elems['element-0']._elems.shape[0])
+        self.history.append('num_nodes', self.objfun.fe.assembly.get_instance('final_model').nodes.shape[0])
+
+    def print_info(self, t0, t1, t2, t3) -> None:
+        """
+        Print the current information of the optimization process.
+        """
+        print(f"Iteration: {self.history.iteration}")
+        print(self.objfun)
+        print(f"Loss: {self.history.history_objective[-1]:.6f}")
+        print("Time Breakdown:")
+        print(f"  Initialization Time: {t1 - t0:.2f} seconds")
+        print(f"  FEA Time: {t2 - t1:.2f} seconds")
+        print(f"  Update Time: {t3 - t2:.2f} seconds")
+        print(f"  Total Time: {t3 - t0:.2f} seconds")
+        print("-" * 50)
+
+    def save(self) -> None:
+        """
+        Save the current state of the optimization process.
+        """
+        self.params.save(foldpath=self.path_result + '/log/', iteration=self.history.iteration)
+        self.solver.save(foldpath=self.path_result + '/log/', iteration=self.history.iteration)
+        self.updater.save(foldpath=self.path_result + '/log/', iteration=self.history.iteration)
+        self.history.save(foldpath=self.path_result + '/log/', iteration=self.history.iteration)
+        self.objfun.save(foldpath=self.path_result + '/log/', iteration=self.history.iteration)
+
+    def clear_cache(self) -> None:
+        """
+        Clear the cache directory.
+        """
+        self.objfun.K_sp = []
+        self.objfun.K_solver = []
+        self.objfun.U = None
+        self.objfun.ADJu = None
+        self.objfun.fe = None
+
+        torch.cuda.empty_cache()
+        data = gc.collect()
+        print(f"Garbage collector: collected {data} objects.")
+
+    def change_device(self, device: torch.device, obj: object = None) -> None:
+        """
+        Recursively change the device of the finite element model and all nested objects.
+
+        Args:
+            device (torch.device): The target device.
+            obj (object, optional): The object to change the device for. If None, change the device for the Controller instance itself.
+
+        Returns:
+            None
+        """
+        if obj is not None:
+            self._change_device_recursive(obj, device)
+        else:
+            self._change_device_recursive(self, device)
+
+    def _change_device_recursive(self, obj, device, visited=None):
+        """
+        Recursively move tensors to the target device.
+        """
+        if visited is None:
+            visited = set()
+        
+        obj_id = id(obj)
+        if obj_id in visited:
+            return
+        visited.add(obj_id)
+
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                if isinstance(v, torch.Tensor):
+                    obj[k] = v.to(device)
+                else:
+                    self._change_device_recursive(v, device, visited)
+        elif isinstance(obj, list):
+            for i, v in enumerate(obj):
+                if isinstance(v, torch.Tensor):
+                    obj[i] = v.to(device)
+                else:
+                    self._change_device_recursive(v, device, visited)
+        elif isinstance(obj, tuple):
+            for v in obj:
+                self._change_device_recursive(v, device, visited)
+        elif hasattr(obj, '__dict__'):
+            for k, v in list(obj.__dict__.items()):
+                if isinstance(v, torch.Tensor):
+                    setattr(obj, k, v.to(device))
+                else:
+                    self._change_device_recursive(v, device, visited)