pyfemtet 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

pyfemtet/opt/interface/_femtet.py

@@ -34,47 +34,75 @@ from pyfemtet.dispatch_extensions import (
     DispatchExtensionException,
 )
 from pyfemtet.opt.interface import FEMInterface, logger
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 
-def post_activate_message(hwnd):
+def _post_activate_message(hwnd):
     win32gui.PostMessage(hwnd, win32con.WM_ACTIVATE, win32con.WA_ACTIVE, 0)
 
 
 class FemtetInterface(FEMInterface):
-    """Concrete class for the interface with Femtet.
+    """Control Femtet from optimizer.
 
-        Args:
-            femprj_path (str or None, optional): The path to the .femprj file. Defaults to None.
-            model_name (str or None, optional): The name of the analysis model. Defaults to None.
-            connect_method (str, optional): The connection method to use. Can be 'new', 'existing', or 'auto'. Defaults to 'auto'.
-            strictly_pid_specify (bool, optional): If True and connect_method=='new', search launched Femtet process strictly based on its process id.
-            allow_without_project (bool, optional): Allow to launch Femtet with no project file. Default to False.
-            open_result_with_gui (bool, optional): Open analysis result with Femtet GUI. Default to True.
-            parametric_output_indexes_use_as_objective (dict, optional): Parametric output indexes and their directions which will be used as objective functions. Parametric output should be set on Femtet parametric analysis dialog. Note that output 'No.' in dialog is starts with 1, but this 'index' is starts with 0. The key is the 'index', the value is direction ('maximize', 'minimize' or float). Default to None.
-
-        Warning:
-            Even if you specify ``strictly_pid_specify=True`` on the constructor,
-            **the connection behavior is like** ``strictly_pid_specify=False`` **in parallel processing**
-            because of its large overhead.
-            So you should close all Femtet processes before running FEMOpt.optimize()
-            if ``n_parallel`` >= 2.
-
-        Tip:
-            If you search for information about the method to connect python and Femtet, see :func:`connect_femtet`.
+    Args:
+        femprj_path (str, optional):
+            The path to the project file.
+            If not specified, get it from connected Femtet.
+
+        model_name (str, optional):
+            The name of the model.
+            If not specified, get it from connected Femtet or the
+            first model when Femtet open the project file.
+
+        connect_method (str, optional):
+            The connection method.
+            Default is 'auto'. Other valid values are 'new' or 'existing'.
+
+        save_pdt (str, optional):
+            The type to save result file.
+            Can specify 'all' or None. Default is 'all'.
+
+        strictly_pid_specify (bool, optional):
+            Whether to strictly specify the PID in Femtet connection.
+            Default is True.
+
+        allow_without_project (bool, optional):
+            Whether to allow without a project. Default is False.
+
+        open_result_with_gui (bool, optional):
+            Whether to open the result with GUI. Default is True.
+
+        parametric_output_indexes_use_as_objective (dict[int, str or float], optional):
+            A list of parametric output indexes and its direction
+            to use as the objective function. If not specified,
+            it will be None and no parametric outputs are used
+            as objectives.
+
+        **kwargs: Additional arguments from inherited classes.
+
+    Warning:
+        Even if you specify ``strictly_pid_specify=True`` on the constructor,
+        **the connection behavior is like** ``strictly_pid_specify=False`` **in parallel processing**
+        because of its large overhead.
+        So you should close all Femtet processes before running FEMOpt.optimize()
+        if ``n_parallel`` >= 2.
+
+    Tip:
+        If you search for information about the method to
+        connect python and Femtet, see :func:`connect_femtet`.
 
     """
 
     def __init__(
             self,
-            femprj_path=None,
-            model_name=None,
-            connect_method='auto',  # dask worker では __init__ の中で 'new' にするので super() の引数にしない。（しても意味がない）
-            save_pdt='all',  # 'all' or None
-            strictly_pid_specify=True,  # dask worker では True にしたいので super() の引数にしない。
-            allow_without_project=False,  # main でのみ True を許容したいので super() の引数にしない。
-            open_result_with_gui=True,
-            parametric_output_indexes_use_as_objective=None,
+            femprj_path: str = None,
+            model_name: str = None,
+            connect_method: str = 'auto',  # dask worker では __init__ の中で 'new' にするので super() の引数にしない。（しても意味がない）
+            save_pdt: str = 'all',  # 'all' or None
+            strictly_pid_specify: bool = True,  # dask worker では True にしたいので super() の引数にしない。
+            allow_without_project: bool = False,  # main でのみ True を許容したいので super() の引数にしない。
+            open_result_with_gui: bool = True,
+            parametric_output_indexes_use_as_objective: dict[int, str or float] = None,
             **kwargs  # 継承されたクラスからの引数
     ):
 
@@ -102,8 +130,8 @@ class FemtetInterface(FEMInterface):
         self.max_api_retry = 3
         self.strictly_pid_specify = strictly_pid_specify
         self.parametric_output_indexes_use_as_objective = parametric_output_indexes_use_as_objective
-        self._original_autosave_enabled = get_autosave_enabled()
-        set_autosave_enabled(False)
+        self._original_autosave_enabled = _get_autosave_enabled()
+        _set_autosave_enabled(False)
 
         # dask サブプロセスのときは femprj を更新し connect_method を new にする
         try:
@@ -145,7 +173,7 @@ class FemtetInterface(FEMInterface):
         )
 
     def __del__(self):
-        set_autosave_enabled(self._original_autosave_enabled)
+        _set_autosave_enabled(self._original_autosave_enabled)
         if self.quit_when_destruct:
             self.quit()
         # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
@@ -170,12 +198,12 @@ class FemtetInterface(FEMInterface):
         """Connects to a Femtet process.
 
         Args:
-            connect_method (str, optional): The connection method. Can be 'new', 'existing', or 'auto'. Defaults to 'new'.
+            connect_method (str, optional): The connection method. Can be 'new', 'existing', or 'auto'. Defaults to 'auto'.
             pid (int or None, optional): The process ID of an existing Femtet process and wanted to connect.
 
         Note:
             When connect_method is 'new', starts a new Femtet process and connects to it.
-            **`pid` will be ignored.**
+            `pid` will be ignored.
 
         Note:
             When 'existing', connect to an existing Femtet process.
@@ -338,11 +366,11 @@ class FemtetInterface(FEMInterface):
             # さらに、プロジェクトツリーが開いていないとアクティブ化イベントも意味がないらしい。
             if fun.__name__ == 'ReExecute':
                 if self.open_result_with_gui or self.parametric_output_indexes_use_as_objective:
-                    post_activate_message(self.Femtet.hWnd)
+                    _post_activate_message(self.Femtet.hWnd)
                 # API を実行
                 returns = fun(*args, **kwargs)  # can raise pywintypes.error
                 if self.open_result_with_gui or self.parametric_output_indexes_use_as_objective:
-                    post_activate_message(self.Femtet.hWnd)
+                    _post_activate_message(self.Femtet.hWnd)
             else:
                 returns = fun(*args, **kwargs)
 
@@ -670,9 +698,25 @@ class FemtetInterface(FEMInterface):
         self.postprocess(self.Femtet)
 
     def preprocess(self, Femtet):
+        """A method called just before :func:`solve`.
+
+        This method is called just before solve.
+        By inheriting from the Interface class
+        and overriding this method, it is possible
+        to perform any desired preprocessing after
+        the model update and before solving.
+        """
         pass
 
     def postprocess(self, Femtet):
+        """A method called just after :func:`solve`.
+
+        This method is called just after solve.
+        By inheriting from the Interface class
+        and overriding this method, it is possible
+        to perform any desired postprocessing after
+        the solve and before evaluating objectives.
+        """
         pass
 
     def quit(self, timeout=1, force=True):
@@ -723,9 +767,9 @@ class FemtetInterface(FEMInterface):
     def _version(self):
         return _version(Femtet=self.Femtet)
 
-    def create_postprocess_args(self):
-        file_content = self.create_result_file_content()
-        jpg_content = self.create_jpg_content()
+    def _create_postprocess_args(self):
+        file_content = self._create_result_file_content()
+        jpg_content = self._create_jpg_content()
 
         out = dict(
             original_femprj_path=self.original_femprj_path,
@@ -736,14 +780,14 @@ class FemtetInterface(FEMInterface):
         return out
 
     @staticmethod
-    def create_pdt_path(femprj_path, model_name, trial):
+    def _create_pdt_path(femprj_path, model_name, trial):
         result_dir = femprj_path.replace('.femprj', '.Results')
         pdt_path = os.path.join(result_dir, model_name + f'_trial{trial}.pdt')
         return pdt_path
 
     # noinspection PyMethodOverriding
     @staticmethod
-    def postprocess_func(
+    def _postprocess_func(
             trial: int,
             original_femprj_path: str,
             model_name: str,
@@ -753,7 +797,7 @@ class FemtetInterface(FEMInterface):
     ):
         result_dir = original_femprj_path.replace('.femprj', '.Results')
         if pdt_file_content is not None:
-            pdt_path = FemtetInterface.create_pdt_path(original_femprj_path, model_name, trial)
+            pdt_path = FemtetInterface._create_pdt_path(original_femprj_path, model_name, trial)
             with open(pdt_path, 'wb') as f:
                 f.write(pdt_file_content)
 
@@ -762,7 +806,7 @@ class FemtetInterface(FEMInterface):
             with open(jpg_path, 'wb') as f:
                 f.write(jpg_file_content)
 
-    def create_result_file_content(self):
+    def _create_result_file_content(self):
         """Called after solve"""
         if self.save_pdt == 'all':
             # save to worker space
@@ -786,7 +830,7 @@ class FemtetInterface(FEMInterface):
         else:
             return None
 
-    def create_jpg_content(self):
+    def _create_jpg_content(self):
         result_dir = self.femprj_path.replace('.femprj', '.Results')
         jpg_path = os.path.join(result_dir, self.model_name + '.jpg')
 
@@ -860,35 +904,37 @@ class _UnPicklableNoFEM(FemtetInterface):
 
 
 # レジストリのパスと値の名前
-REGISTRY_PATH: Final[str] = r"SOFTWARE\Murata Software\Femtet2014\Femtet"
-VALUE_NAME: Final[str] = "AutoSave"
+_REGISTRY_PATH: Final[str] = r"SOFTWARE\Murata Software\Femtet2014\Femtet"
+_VALUE_NAME: Final[str] = "AutoSave"
 
-def get_autosave_enabled() -> bool:
-    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, REGISTRY_PATH) as key:
-        value, regtype = winreg.QueryValueEx(key, VALUE_NAME)
+
+def _get_autosave_enabled() -> bool:
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH) as key:
+        value, regtype = winreg.QueryValueEx(key, _VALUE_NAME)
         if regtype == winreg.REG_DWORD:
             return bool(value)
         else:
             raise ValueError("Unexpected registry value type.")
 
-def set_autosave_enabled(enable: bool) -> None:
-    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, REGISTRY_PATH, 0, winreg.KEY_SET_VALUE) as key:
-        winreg.SetValueEx(key, VALUE_NAME, 0, winreg.REG_DWORD, int(enable))
+
+def _set_autosave_enabled(enable: bool) -> None:
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _REGISTRY_PATH, 0, winreg.KEY_SET_VALUE) as key:
+        winreg.SetValueEx(key, _VALUE_NAME, 0, winreg.REG_DWORD, int(enable))
 
 
 def _test_autosave_setting():
 
     # 使用例
-    current_setting = get_autosave_enabled()
+    current_setting = _get_autosave_enabled()
     print(f"Current AutoSave setting is {'enabled' if current_setting else 'disabled'}.")
 
     # 設定を変更する例
     new_setting = not current_setting
-    set_autosave_enabled(new_setting)
+    _set_autosave_enabled(new_setting)
     print(f"AutoSave setting has been {'enabled' if new_setting else 'disabled'}.")
 
     # 再度設定を確認する
-    after_setting = get_autosave_enabled()
+    after_setting = _get_autosave_enabled()
     print(f"Current AutoSave setting is {'enabled' if after_setting else 'disabled'}.")
 
     assert new_setting == after_setting, "レジストリ編集に失敗しました。" 

pyfemtet/opt/interface/_femtet_with_nx/_interface.py

@@ -7,23 +7,47 @@ from dask.distributed import get_worker
 
 from pyfemtet.core import ModelError
 from pyfemtet.opt.interface import FemtetInterface, logger
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 
 here, me = os.path.split(__file__)
 
 
 class FemtetWithNXInterface(FemtetInterface):
-    """Femtet with NX interface class.
+    """Control Femtet and NX.
 
-    Args:
-        prt_path: The path to the prt file.
-        export_curves(bool or None): Parasolid export setting of NX. If None, PyFemtet does not change the setting of NX. Defaults to None.
-        export_surfaces(bool or None): Parasolid export setting of NX. If None, PyFemtet does not change the setting of NX. Defaults to None.
-        export_solids(bool or None): Parasolid export setting of NX. If None, PyFemtet does not change the setting of NX. Defaults to None.
-        export_flattened_assembly(bool or None): Parasolid export setting of NX. If None, PyFemtet does not change the setting of NX. Defaults to None.
+    Using this class, you can import CAD files created
+    in NX through the Parasolid format into a
+    Femtet project. It allows you to pass design
+    variables to NX, update the model, and
+    perform analysis using the updated model in Femtet.
 
-    For details of The other arguments, see ``FemtetInterface``.
+    Args:
+        prt_path (str):
+            The path to .prt file containing the
+            CAD data from which the import is made.
+
+        export_curves(bool or None, optional):
+            Defaults to None.
+        export_surfaces(bool or None, optional):
+            Defaults to None.
+        export_solids(bool or None, optional):
+            Defaults to None.
+        export_flattened_assembly(bool or None, optional):
+            Defaults to None.
+        **kwargs:
+            For other arguments, please refer to the
+            :class:`FemtetInterface` class.
+
+    Notes:
+        ```export_*``` arguments sets
+        parasolid export setting of NX.
+        If None, PyFemtet does not change
+        the current setting of NX.
+
+        It is recommended not to change these values
+        from the settings used when exporting the
+        Parasolid that was imported into Femtet.
 
     """
 
@@ -84,7 +108,7 @@ class FemtetWithNXInterface(FemtetInterface):
         )
         super()._setup_before_parallel(client)
 
-    def update_model(self, parameters: 'pd.DataFrame') -> None:
+    def update_model(self, parameters: 'pd.DataFrame', with_warning=False) -> None:
         """Update .x_t"""
 
         self.parameters = parameters.copy()
@@ -151,5 +175,4 @@ class FemtetWithNXInterface(FemtetInterface):
         )
 
         # femprj モデルの変数も更新
-        super().update_model(parameters)
-
+        super().update_model(parameters, with_warning=False)

pyfemtet/opt/interface/_femtet_with_sldworks.py

@@ -10,10 +10,30 @@ from pythoncom import CoInitialize, CoUninitialize
 
 from pyfemtet.core import ModelError
 from pyfemtet.opt.interface import FemtetInterface, logger
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 
 class FemtetWithSolidworksInterface(FemtetInterface):
+    """Control Femtet and Solidworks.
+
+    Using this class, you can import CAD files created
+    in Solidworks through the Parasolid format into a
+    Femtet project. It allows you to pass design
+    variables to Solidworks, update the model, and
+    perform analysis using the updated model in Femtet.
+
+
+    Args:
+        sldprt_path (str):
+            The path to .sldprt file containing the
+            CAD data from which the import is made.
+        **kwargs:
+            For other arguments, please refer to the
+            :class:`FemtetInterface` class.
+
+    """
+
+
     # 定数の宣言
     swThisConfiguration = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
     swAllConfiguration = 2
@@ -76,7 +96,7 @@ class FemtetWithSolidworksInterface(FemtetInterface):
         CoInitialize()
         self.initialize_sldworks_connection()
 
-    def update_model(self, parameters: pd.DataFrame):
+    def update_model(self, parameters: pd.DataFrame, with_warning=False):
         """Update .x_t"""
 
         self.parameters = parameters.copy()

pyfemtet/opt/optimizer/_base.py

@@ -8,13 +8,12 @@ from time import sleep
 
 # 3rd-party
 import numpy as np
-import pandas as pd
 
 # pyfemtet relative
-from pyfemtet.opt.interface import FemtetInterface
+from pyfemtet.opt.interface import FEMInterface
 from pyfemtet.opt._femopt_core import OptimizationStatus, Objective, Constraint
-from pyfemtet.message import Msg
-from pyfemtet.opt.parameter import ExpressionEvaluator
+from pyfemtet._message import Msg
+from pyfemtet.opt.optimizer.parameter import ExpressionEvaluator, Parameter
 
 # logger
 import logging
@@ -117,17 +116,11 @@ class AbstractOptimizer(ABC):
         fem (FEMInterface): The finite element method object.
         fem_class (type): The class of the finite element method object.
         fem_kwargs (dict): The keyword arguments used to instantiate the finite element method object.
-        parameters (pd.DataFrame): The parameters used in the optimization.
-        objectives (dict): A dictionary containing the objective functions used in the optimization.
-        constraints (dict): A dictionary containing the constraint functions used in the optimization.
-        entire_status (OptimizationStatus): The status of the entire optimization process.
+        variables (ExpressionEvaluator): The variables using optimization process including parameters.
+        objectives (dict[str, Objective]): A dictionary containing the objective functions used in the optimization.
+        constraints (dict[str, Constraint]): A dictionary containing the constraint functions used in the optimization.
         history (History): An actor object that records the history of each iteration in the optimization process.
-        worker_status (OptimizationStatus): The status of each worker in a distributed computing environment.
-        message (str): A message associated with the current state of the optimization process.
         seed (int or None): The random seed used for random number generation during the optimization process.
-        timeout (float or int or None): The maximum time allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
-        n_trials (int or None): The maximum number of trials allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
-        is_cluster (bool): Flag indicating if running on a distributed computing cluster.
 
     """
 
@@ -150,9 +143,33 @@ class AbstractOptimizer(ABC):
         self._exception = None
         self.method_checker: OptimizationMethodChecker = OptimizationMethodChecker(self)
 
-    def f(self, x):
-        """Get x, update fem analysis, return objectives (and constraints)."""
-        # interruption の実装は具象クラスに任せる
+    # ===== algorithm specific methods =====
+    @abstractmethod
+    def run(self) -> None:
+        """Start optimization."""
+        pass
+
+    # ----- FEMOpt interfaces -----
+    @abstractmethod
+    def _setup_before_parallel(self, *args, **kwargs):
+        """Setup before parallel processes are launched."""
+        pass
+
+    # ===== calc =====
+    def f(self, x: np.ndarray) -> list[np.ndarray]:
+        """Calculate objectives and constraints.
+
+        Args:
+            x (np.ndarray): Optimization parameters.
+
+        Returns:
+            list[np.ndarray]:
+                The list of internal objective values,
+                un-normalized objective values and
+                constraint values.
+
+        """
+
 
         if isinstance(x, np.float64):
             x = np.array([x])
@@ -202,8 +219,8 @@ class AbstractOptimizer(ABC):
             y,
             c,
             self.message,
-            postprocess_func=self.fem.postprocess_func,
-            postprocess_args=self.fem.create_postprocess_args(),
+            postprocess_func=self.fem._postprocess_func,
+            postprocess_args=self.fem._create_postprocess_args(),
         )
 
         logger.debug('history.record end')
@@ -212,26 +229,21 @@ class AbstractOptimizer(ABC):
 
         return np.array(y), np.array(_y), np.array(c)
 
-    def _reconstruct_fem(self, skip_reconstruct=False):
-        """Reconstruct FEMInterface in a subprocess."""
-        # reconstruct fem
-        if not skip_reconstruct:
-            self.fem = self.fem_class(**self.fem_kwargs)
-
-        # COM 定数の restore
-        for obj in self.objectives.values():
-            obj._restore_constants()
-        for cns in self.constraints.values():
-            cns._restore_constants()
-
+    # ===== parameter processing =====
     def get_parameter(self, format='dict'):
         """Returns the parameters in the specified format.
 
         Args:
-            format (str, optional): The desired format of the parameters. Can be 'df' (DataFrame), 'value' (alias of values), 'values' (np.ndarray), or 'dict'. Defaults to 'dict'.
+            format (str, optional):
+                The desired format of the parameters.
+                Can be 'df' (DataFrame),
+                'values' (np.ndarray),
+                'dict' or
+                'raw' (list of Variable object).
+                Defaults to 'dict'.
 
         Returns:
-            object: The parameters in the specified format.
+            The parameters in the specified format.
 
         Raises:
             ValueError: If an invalid format is provided.
@@ -239,11 +251,14 @@ class AbstractOptimizer(ABC):
         """
         return self.variables.get_variables(format=format, filter_parameter=True)
 
-    def set_parameter(self, params: dict) -> None:
+    def set_parameter(self, params: dict[str, float]) -> None:
         """Update parameter.
 
         Args:
-            params (dict): Key is the name of parameter and the value is the value of it. The partial set is available.
+            params (dict):
+                Key is the name of parameter and
+                the value is the value of it.
+                The partial set is available.
 
         """
         for name, value in params.items():
@@ -255,11 +270,25 @@ class AbstractOptimizer(ABC):
 
         Args:
             values (np.ndarray): Values of all parameters.
+
         """
         prm_names = self.variables.get_parameter_names()
         assert len(values) == len(prm_names)
         self.set_parameter({k: v for k, v in zip(prm_names, values)})
 
+    # ===== FEMOpt interfaces =====
+    def _reconstruct_fem(self, skip_reconstruct=False):
+        """Reconstruct FEMInterface in a subprocess."""
+        # reconstruct fem
+        if not skip_reconstruct:
+            self.fem = self.fem_class(**self.fem_kwargs)
+
+        # COM 定数の restore
+        for obj in self.objectives.values():
+            obj._restore_constants()
+        for cns in self.constraints.values():
+            cns._restore_constants()
+
     def _check_interruption(self):
         """"""
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
@@ -275,6 +304,7 @@ class AbstractOptimizer(ABC):
         if not self.worker_status.get() == OptimizationStatus.CRASHED:
             self.worker_status.set(OptimizationStatus.TERMINATED)
 
+    # run via FEMOpt (considering parallel processing)
     def _run(
             self,
             subprocess_idx,
@@ -331,12 +361,16 @@ class AbstractOptimizer(ABC):
 
         return self._exception
 
-    @abstractmethod
-    def run(self) -> None:
-        """Start calculation using optimization library."""
-        pass
 
-    @abstractmethod
-    def _setup_before_parallel(self, *args, **kwargs):
-        """Setup before parallel processes are launched."""
-        pass
+if __name__ == '__main__':
+    class Optimizer(AbstractOptimizer):
+        def run(self): pass
+        def _setup_before_parallel(self, *args, **kwargs): pass
+
+    opt = Optimizer()
+    opt.set_parameter(
+        dict(
+            prm1=0.,
+            prm2=1.,
+        )
+    )

pyfemtet/opt/optimizer/_optuna.py

@@ -14,7 +14,7 @@ from optuna.study import MaxTrialsCallback
 from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs, Constraint
 from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.core import MeshError, ModelError, SolveError
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 # filter warnings
 import warnings
@@ -37,6 +37,38 @@ class OptunaMethodChecker(OptimizationMethodChecker):
 
 
 class OptunaOptimizer(AbstractOptimizer):
+    """Optimizer using ```optuna```.
+
+    This class provides an interface for the optimization
+    engine using Optuna. For more details, please refer to
+    the Optuna documentation.
+
+    See Also:
+        https://optuna.readthedocs.io/en/stable/reference/index.html
+
+    Args:
+        sampler_class (optuna.samplers.BaseSampler, optional):
+            A sampler class from Optuna. If not specified,
+            ```optuna.samplers.TPESampler``` is specified.
+            This defines the sampling strategy used during
+            optimization. Defaults to None.
+        sampler_kwargs (dict, optional):
+            A dictionary of keyword arguments to be passed to
+            the sampler class. This allows for customization
+            of the sampling process. Defaults to None.
+        add_init_method (str or Iterable[str], optional):
+            A method or a collection of methods to be added
+            during initialization. This can be used to specify
+            additional setup procedures.
+            Currently, the only valid value is 'LHS'
+            (using Latin Hypercube Sampling).
+            Defaults to None.
+
+    Warnings:
+        Do not include ```constraints_func``` in ```sampler_kwargs```.
+        It is generated and provided by :func:`FEMOpt.add_constraint`.
+
+    """
 
     def __init__(
             self,

pyfemtet/opt/optimizer/_optuna_botorchsampler_parameter_constraint_helper.py

@@ -15,7 +15,7 @@ from botorch.optim.initializers import gen_batch_initial_conditions
 
 from pyfemtet.opt._femopt_core import Constraint
 from pyfemtet.opt.optimizer import OptunaOptimizer, logger
-from pyfemtet.message import Msg
+from pyfemtet._message import Msg
 
 from time import time
 
@@ -183,7 +183,6 @@ class NonlinearInequalityConstraints:
                 item = (lambda x: GeneralFunctionWithForwardDifference.apply(cns_botorch, x), True)
                 self._nonlinear_inequality_constraints.append(item)
 
-
     def _filter_feasible_conditions(self, ic_batch):
         # List to store feasible initial conditions
         feasible_ic_list = []