pyfemtet 0.9.6__py3-none-any.whl → 1.0.0__py3-none-any.whl

pyfemtet/opt/interface/{_femtet.py → _femtet_interface/femtet_interface.py}

@@ -1,16 +1,12 @@
-import warnings
-from typing import Optional, List, Final
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import os
 import sys
-from time import sleep, time
-import winreg
 import subprocess
-
-import pandas as pd
-import psutil
-import shutil
-from dask.distributed import get_worker
+from time import sleep
+from contextlib import nullcontext
 
 # noinspection PyUnresolvedReferences
 from pywintypes import com_error, error
@@ -20,32 +16,31 @@ from pythoncom import CoInitialize, CoUninitialize
 from win32com.client import constants
 import win32con
 import win32gui
-from femtetutils import util
-
-from pyfemtet.core import (
-    ModelError,
-    MeshError,
-    SolveError,
-    _version,
-)
-from pyfemtet.dispatch_extensions import (
-    dispatch_femtet,
-    dispatch_specific_femtet,
-    launch_and_dispatch_femtet,
-    _get_pid,
-    _get_pids,
-    DispatchExtensionException,
-)
-from pyfemtet.opt.interface._base import FEMInterface
-from pyfemtet._message import Msg
-from pyfemtet._femtet_config_util.autosave import _get_autosave_enabled, _set_autosave_enabled
-from pyfemtet._femtet_config_util.exit import _exit_or_force_terminate
-
-if __name__ == '__main__':
-    from pyfemtet.logger import get_module_logger
-    logger = get_module_logger('opt.interface.FemtetInterface', __name__)
-else:
-    from pyfemtet.opt.interface._base import logger
+
+import pandas as pd
+
+from pyfemtet.logger import get_module_logger
+
+from pyfemtet._i18n import Msg, _
+from pyfemtet._util.helper import *
+from pyfemtet._util.dask_util import *
+from pyfemtet._util.femtet_exit import *
+from pyfemtet._util.process_util import *
+from pyfemtet._util.femtet_version import *
+from pyfemtet._util.femtet_autosave import *
+from pyfemtet._util.femtet_access_inspection import *
+
+from pyfemtet.dispatch_extensions import *
+from pyfemtet.opt.interface._base_interface import COMInterface
+from pyfemtet.opt.exceptions import *
+from pyfemtet.opt.problem.variable_manager import SupportedVariableTypes
+
+from ._femtet_parametric import *
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+logger = get_module_logger('opt.interface', False)
 
 
 def _post_activate_message(hwnd):
@@ -56,10 +51,7 @@ class FailedToPostProcess(Exception):
     pass
 
 
-
-
-
-class FemtetInterface(FEMInterface):
+class FemtetInterface(COMInterface):
     """Control Femtet from optimizer.
 
     Args:
@@ -110,8 +102,6 @@ class FemtetInterface(FEMInterface):
                 If you do not want to delete the swept table,
                 make a copy of the original file.
 
-        **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**
@@ -125,24 +115,32 @@ class FemtetInterface(FEMInterface):
 
     """
 
+    com_members = {'Femtet': 'FemtetMacro.Femtet'}
+    _show_parametric_index_warning = True  # for GUI
+    _femtet_connection_timeout = 10
+
     def __init__(
             self,
             femprj_path: str = None,
             model_name: str = None,
-            connect_method: str = 'auto',  # dask worker では __init__ の中で 'new' にするので super() の引数にしない。（しても意味がない）
-            save_pdt: str = 'all',  # 'all', 'none' or 'optimal'
+            connect_method: str = "auto",  # dask worker では __init__ の中で 'new' にする
+            save_pdt: str = "all",  # 'all', 'none' or 'optimal'
             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  # 継承されたクラスからの引数
+            always_open_copy=False,
+            # ユーザーはメソッドを使うことを推奨。GUI などで使用。
+            parametric_output_indexes_use_as_objective: dict[int, str | float] = None,
     ):
-        # warning
         if parametric_output_indexes_use_as_objective is not None:
-            warnings.warn('解析モデルに設定された既存のスイープテーブルは削除されます。')
-
-        # win32com の初期化
-        CoInitialize()
+            if FemtetInterface._show_parametric_index_warning:
+                logger.warning(_(
+                    en_message='The argument `parametric_output_indexes_use_as_objective` is deprecated. '
+                               'Please use `FemtetInterface.use_parametric_output_as_objective()` instead.',
+                    jp_message='`parametric_output_indexes_use_as_objective` は非推奨の引数です。'
+                               '代わりに `FemtetInterface.use_parametric_output_as_objective()` '
+                               'を使ってください。',
+                ))
 
         # 引数の処理
         if femprj_path is None:
@@ -152,86 +150,135 @@ class FemtetInterface(FEMInterface):
         self.model_name = model_name
         self.connect_method = connect_method
         self.allow_without_project = allow_without_project
-        self.original_femprj_path = self.femprj_path
+        self._original_femprj_path = self.femprj_path
         self.open_result_with_gui = open_result_with_gui
         self.save_pdt = save_pdt
+        self._always_open_copy = always_open_copy
 
         # その他のメンバーの宣言や初期化
         self.Femtet = None
         self.femtet_pid = 0
         self.quit_when_destruct = False
-        self.connected_method = 'unconnected'
-        self.parameters = None
+        self.connected_method = "unconnected"
         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._load_problem_from_fem = self.parametric_output_indexes_use_as_objective is not None
         self._original_autosave_enabled = _get_autosave_enabled()
         _set_autosave_enabled(False)
+        self._warn_if_undefined_variable = True
+        self.api_response_warning_time = 10  # mesh, solve, re-execute を除くマクロ実行警告時間
 
-        # dask サブプロセスのときは femprj を更新し connect_method を new にする
-        try:
-            worker = get_worker()
-            space = worker.local_directory
-            # worker なら femprj_path が None でないはず
-            self.femprj_path = os.path.join(space, os.path.basename(self.femprj_path))
-            self.connect_method = 'new'
-            self.strictly_pid_specify = False
-        except ValueError:  # get_worker に失敗した場合
-            pass
-
-        # femprj_path と model に基づいて Femtet を開き、
-        # 開かれたモデルに応じて femprj_path と model を更新する
+        # connect to Femtet
         self._connect_and_open_femtet()
+        assert self.connected_method != 'unconnected'
+
+        if self._always_open_copy:
+            # 現時点でFemtet に model を close する機能がない
+            #   + executor でも CAD 連携等でモデルに
+            #   わかりにくい変更が入らないように
+            #   _tmp_dir のファイルを開くようにしたため
+            #   _tmp_dir 削除時の permission error を
+            #   避けるために Femtet を強制 close する
+            # Femtet で model が close できるようになれば
+            #   この条件分岐は不要になる
+            self.quit_when_destruct = True
 
-        # original_fem_prj が None なら必ず
-        # dask worker でないプロセスがオリジナルファイルを開いている
-        if self.original_femprj_path is None:
-            # dask worker でなければ original のはず
-            try:
-                _ = get_worker()
-            except ValueError:
-                self.original_femprj_path = self.femprj_path
-
-        # 接続した Femtet の種類に応じて del 時に quit するかどうか決める
-        self.quit_when_destruct = self.connected_method == 'new'
+        else:
+            # 接続した Femtet の種類に応じて del 時に quit するかどうか決める
+            self.quit_when_destruct = self.connected_method == "new"
 
-        # subprocess で restore するための情報保管
-        # パスなどは connect_and_open_femtet での処理結果を反映し
-        # メインで開いた解析モデルが確実に開かれるようにする
-        FEMInterface.__init__(
-            self,
-            femprj_path=self.femprj_path,
-            model_name=self.model_name,
-            open_result_with_gui=self.open_result_with_gui,
-            parametric_output_indexes_use_as_objective=self.parametric_output_indexes_use_as_objective,
-            save_pdt=self.save_pdt,
-            **kwargs
-        )
+    # ===== system =====
 
     @property
-    def object_passed_to_functions(self):
+    def object_pass_to_fun(self):
+        """The object pass to the first argument of user-defined objective functions.
+
+        Returns:
+            Femtet (CDispatch): COM object of Femtet.
+        """
         return self.Femtet
 
-    def use_parametric_output_as_objective(self, number: int, direction: str | float = 'minimize') -> None:
+    def _setup_before_parallel(self):
+        self._distribute_files([self.femprj_path])
+
+    def _setup_after_parallel(self, opt: AbstractOptimizer = None):
+
+        # main worker かつ always_open_copy でないときのみ
+        # femprj_path を切り替えない
+        if (get_worker() is None) and not self._always_open_copy:
+            pass
+
+        # worker space の femprj に切り替える
+        else:
+            suffix = self._get_worker_index_from_optimizer(opt)
+            self.femprj_path = self._rename_and_get_path_on_worker_space(self._original_femprj_path, suffix)
+
+        # dask process ならば Femtet を起動
+        worker = get_worker()
+        if worker is not None:
+            CoInitialize()
+            self.connect_femtet(connect_method='new')
+            self.quit_when_destruct = True
+
+        # femprj を開く
+        self.open(self.femprj_path, self.model_name)
+
+    def close(self, timeout=15, force=True):  # 12 秒程度
+        """Force to terminate connected Femtet."""
+
+        _set_autosave_enabled(self._original_autosave_enabled)
+
+        if not hasattr(self, 'Femtet'):
+            return
+
+        if self.Femtet is None:
+            return
+
+        if self.quit_when_destruct:
+            logger.info(_('Closing Femtet (pid = {pid}) ...', pid=self.femtet_pid))
+            succeeded = _exit_or_force_terminate(
+                timeout=timeout, Femtet=self.Femtet, force=force)
+            if succeeded:
+                logger.info(_('Femtet is closed.'))
+            else:
+                logger.warning(_('Failed to close Femtet.'))
+
+    def use_parametric_output_as_objective(
+            self, number: int, direction: str | float = "minimize"
+    ) -> None:
         """Use output setting of Femtet parametric analysis as an objective function.
 
         Args:
             number (int): The index of output settings tab in parametric analysis dialog of Femtet. Starts at 1.
-            direction (str | float): Objective direction. Valid input is one of 'minimize', 'maximize' or a specific value. Defaults to 'minimize'.
+            direction (str | float): Objective direction.
+                Valid input is one of 'minimize', 'maximize' or a specific value.
+                Defaults to 'minimize'.
 
         Returns:
             None
 
         """
+
+        # warning
+        logger.warning(_(
+            en_message='The existing sweep table in the project will be removed.',
+            jp_message='解析モデルに設定された既存のスイープテーブルは削除されます。'
+        ))
+
         # check
         if isinstance(direction, str):
-            if direction not in ('minimize', 'maximize'):
-                raise ValueError(f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}')
+            if direction not in ("minimize", "maximize"):
+                raise ValueError(
+                    f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}'
+                )
         else:
             try:
                 direction = float(direction)
             except (TypeError, ValueError):
-                raise ValueError(f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}')
+                raise ValueError(
+                    f'direction must be one of "minimize", "maximize" or a specific value. Passed value is {direction}'
+                )
 
         index = {number - 1: direction}
 
@@ -241,35 +288,44 @@ class FemtetInterface(FEMInterface):
         else:
             self.parametric_output_indexes_use_as_objective.update(index)
 
-        # TODO: FEMInterface.__init__ の仕様を変えたらここも変える
-        self.kwargs['parametric_output_indexes_use_as_objective'] = self.parametric_output_indexes_use_as_objective
+        self._load_problem_from_fem = True
+
+    def load_objectives(self, opt: AbstractOptimizer):
+        indexes = list(self.parametric_output_indexes_use_as_objective.keys())
+        directions = list(self.parametric_output_indexes_use_as_objective.values())
+        add_parametric_results_as_objectives(
+            opt, self.Femtet, indexes, directions
+        )
 
+    def _check_using_fem(self, fun: callable):
+        return _is_access_femtet(fun)
 
-    def __del__(self):
-        self.quit()
-        # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
+    # ===== connect_femtet =====
 
     def _connect_new_femtet(self):
-        logger.info('└ Try to launch and connect new Femtet process.')
+        logger.info("└ Try to launch and connect new Femtet process.")
 
-        self.Femtet, self.femtet_pid = launch_and_dispatch_femtet(strictly_pid_specify=self.strictly_pid_specify)
+        self.Femtet, self.femtet_pid = launch_and_dispatch_femtet(
+            strictly_pid_specify=self.strictly_pid_specify
+        )
 
-        self.connected_method = 'new'
+        self.connected_method = "new"
 
     def _connect_existing_femtet(self, pid: int or None = None):
-        logger.info('└ Try to connect existing Femtet process.')
+        logger.info("└ Try to connect existing Femtet process.")
         # 既存の Femtet を探して Dispatch する。
         if pid is None:
-            self.Femtet, self.femtet_pid = dispatch_femtet(timeout=5)
+            self.Femtet, self.femtet_pid = dispatch_femtet(timeout=self._femtet_connection_timeout)
         else:
-            self.Femtet, self.femtet_pid = dispatch_specific_femtet(pid, timeout=5)
-        self.connected_method = 'existing'
+            self.Femtet, self.femtet_pid = dispatch_specific_femtet(pid, timeout=self._femtet_connection_timeout)
+        self.connected_method = "existing"
 
-    def connect_femtet(self, connect_method: str = 'auto', pid: int or None = None):
+    def connect_femtet(self, connect_method: str = "auto", pid: int or None = None):
         """Connects to a Femtet process.
 
         Args:
-            connect_method (str, optional): The connection method. Can be 'new', 'existing', or 'auto'. Defaults to 'auto'.
+            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:
@@ -289,33 +345,136 @@ class FemtetInterface(FEMInterface):
 
         """
 
-        if connect_method == 'new':
+        if connect_method == "new":
             self._connect_new_femtet()
 
-        elif connect_method == 'existing':
+        elif connect_method == "existing":
             self._connect_existing_femtet(pid)
 
-        elif connect_method == 'auto':
+        elif connect_method == "auto":
             try:
                 self._connect_existing_femtet(pid)
             except DispatchExtensionException:
                 self._connect_new_femtet()
 
         else:
-            raise Exception(f'{connect_method} は定義されていない接続方法です')
+            raise Exception(f"{connect_method} は定義されていない接続方法です")
 
         # ensure makepy
-        if not hasattr(constants, 'STATIC_C'):
-            cmd = f'{sys.executable} -m win32com.client.makepy FemtetMacro'
+        if not hasattr(constants, "STATIC_C"):
+            cmd = f"{sys.executable} -m win32com.client.makepy FemtetMacro"
             subprocess.run(cmd, shell=True)
-            message = Msg.ERR_NO_MAKEPY
-            logger.error('================')
+
+            message = _(
+                en_message='It was detected that the configuration of '
+                           'Femtet python macro constants has not been '
+                           'completed. The configuration was done '
+                           'automatically '
+                           '(python -m win32com.client.makepy FemtetMacro). '
+                           'Please restart the program. '
+                           'If the error persists, please run '
+                           '"py -m win32com.client.makepy FemtetMacro" '
+                           'or "python -m win32com.client.makepy FemtetMacro" '
+                           'on the command prompt.',
+                jp_message='Femtet Pythonマクロ定数の設定が完了していない'
+                           'ことが検出されました。設定は自動で行われました'
+                           '(py -m win32com.client.makepy FemtetMacro)。 '
+                           'プログラムを再起動してください。'
+                           'エラーが解消されない場合は、'
+                           '"py -m win32com.client.makepy FemtetMacro" か '
+                           '"python -m win32com.client.makepy FemtetMacro" '
+                           'コマンドをコマンドプロンプトで実行してください。'
+            )
+
+            logger.error("================")
             logger.error(message)
-            logger.error('================')
+            logger.error("================")
             raise RuntimeError(message)
 
         if self.Femtet is None:
-            raise RuntimeError(Msg.ERR_FEMTET_CONNECTION_FAILED)
+            raise RuntimeError(_(
+                en_message='Failed to connect to Femtet.',
+                jp_message='Femtet への接続に失敗しました。',
+            ))
+
+    def open(self, femprj_path: str, model_name: str or None = None) -> None:
+        """Open specific analysis model with connected Femtet."""
+
+        # 引数の処理
+        self.femprj_path = os.path.abspath(femprj_path)
+        self.model_name = model_name
+        # 開く
+        if self.model_name is None:
+            result = self.Femtet.LoadProject(self.femprj_path, True)
+        else:
+            result = self.Femtet.LoadProjectAndAnalysisModel(
+                self.femprj_path, self.model_name, True
+            )
+        if not result:
+            self.Femtet.ShowLastError()
+
+    def _connect_and_open_femtet(self):
+        """Connects to a Femtet process and open the femprj.
+
+        This function is for establishing a connection with Femtet and opening the specified femprj file.
+
+        At the beginning of the function, we check if femprj_path is specified.
+
+        If femprj_path is specified, first connect to Femtet using the specified connection method. Then, if the project path of the connected Femtet is different from the specified femprj_path, open the project using the open function. Also, if model_name is specified, the project will be opened using the open function even if the Femtet analysis model name is different from the specified model_name.
+
+        On the other hand, if femprj_path is not specified, an error message will be displayed stating that femprj_path must be specified in order to use the "new" connection method. If the connection method is not "new", it will try to connect to an existing Femtet instance. If the connection is successful, the project path and analysis model name of the Femtet instance will be stored as femprj_path and model_name.
+
+        """
+
+        logger.info(f'Try to connect Femtet (method: "{self.connect_method}").')
+        logger.info(
+            f'│ femprj: {self.femprj_path if self.femprj_path is not None else "not specified."}'
+        )
+        logger.info(
+            f'│ model: {self.model_name if self.femprj_path is not None else "not specified."}'
+        )
+
+        # femprj が指定されている
+        if self.femprj_path is not None:
+            # 指定された方法で接続してみて
+            # 接続した Femtet と指定された femprj 及び model が異なれば
+            # 接続した Femtet で指定された femprj 及び model を開く
+            self.connect_femtet(self.connect_method)
+
+            # プロジェクトの相違をチェック
+            if self.Femtet.ProjectPath != self.femprj_path:
+                self.open(self.femprj_path, self.model_name)
+
+            # モデルが指定されていればその相違もチェック
+            if self.model_name is not None:
+                if self.Femtet.AnalysisModelName != self.model_name:
+                    self.open(self.femprj_path, self.model_name)
+
+        # femprj が指定されていない
+        else:
+            # かつ new だと解析すべき femprj がわからないのでエラー
+            if (self.connect_method == "new") and (not self.allow_without_project):
+                raise RuntimeError(Msg.ERR_NEW_FEMTET_BUT_NO_FEMPRJ)
+
+            # さらに auto の場合は Femtet が存在しなければ new と同じ挙動になるので同様の処理
+            if (
+                (self.connect_method == "auto")
+                and (len(_get_pids(process_name="Femtet.exe")) == 0)
+                and (not self.allow_without_project)
+            ):
+                raise RuntimeError(Msg.ERR_NEW_FEMTET_BUT_NO_FEMPRJ)
+            self.connect_femtet(self.connect_method)
+
+        # 最終的に接続した Femtet の femprj_path と model を インスタンスに戻す
+        self.femprj_path = self.Femtet.Project
+        self.model_name = self.Femtet.AnalysisModelName
+
+        # femprj が指定されていなければこの時点でのパスをオリジナルとする
+        if self._original_femprj_path is None:
+            assert get_worker() is None
+            self._original_femprj_path = self.femprj_path
+
+    # ===== call femtet API =====
 
     def _check_gaudi_accessible(self) -> bool:
         try:
@@ -326,12 +485,12 @@ class FemtetInterface(FEMInterface):
         return True
 
     # noinspection PyMethodMayBeStatic
-    def _construct_femtet_api(self, string):  # static にしてはいけない
+    def _construct_femtet_api(self, string: str | callable):  # static にしてはいけない
         if isinstance(string, str):
-            if string.startswith('self.'):
+            if string.startswith("self."):
                 return eval(string)
             else:
-                return eval('self.' + string)
+                return eval("self." + string)
         else:
             return string  # Callable
 
@@ -348,6 +507,74 @@ class FemtetInterface(FEMInterface):
             recourse_depth=0,
             print_indent=0,
     ):
+
+        context = None
+
+        # Solve, Mesh, ReExecute は時間計測しない
+        if callable(fun):
+            name = fun.__name__
+            if fun.__name__ == 'Solve':
+                context = nullcontext()
+            elif fun.__name__ == 'solve_via_parametric_dll':
+                context = nullcontext()
+
+        elif isinstance(fun, str):
+
+            if fun in ('self.Femtet.Gaudi.ReExecute', 'self.Femtet.Gaudi.Mesh'):
+                context = nullcontext()
+            name = fun.split('.')[-1]
+
+        else:
+            raise NotImplementedError
+
+        if context is None:
+            warning_time_sec = self.api_response_warning_time
+            context = time_counting(
+                name=name,
+                warning_time_sec=warning_time_sec,
+                warning_fun=lambda: logger.warning(
+                    _(
+                        '{name} does not finish in {warning_time_sec} seconds. '
+                        'If the optimization is hanging, the most reason is '
+                        'a dialog is opening in Femtet and it waits for your '
+                        'input. Please confirm there is no dialog in Femtet.',
+                        '{name} の実行に {warning_time_sec} 秒以上かかっています。'
+                        'もし最適化がハングしているならば、考えられる理由として、'
+                        'Femtet で予期せずダイアログが開いてユーザーの入力待ちをしている場合があります。'
+                        'もし Femtet でダイアログが開いていれば、閉じてください。',
+                        name=name,
+                        warning_time_sec=warning_time_sec,
+                    )
+                ),
+            )
+
+        with context:
+            return self._call_femtet_api_core(
+                fun,
+                return_value_if_failed,
+                if_error,
+                error_message,
+                is_Gaudi_method,
+                ret_for_check_idx,
+                args,
+                kwargs,
+                recourse_depth,
+                print_indent,
+            )
+
+    def _call_femtet_api_core(
+        self,
+        fun,
+        return_value_if_failed,
+        if_error,
+        error_message,
+        is_Gaudi_method=False,
+        ret_for_check_idx=None,
+        args=None,
+        kwargs=None,
+        recourse_depth=0,
+        print_indent=0,
+    ):
         """Internal method. Call Femtet API with error handling.
 
         Parameters
@@ -390,26 +617,33 @@ class FemtetInterface(FEMInterface):
 
         # 実行する API をデバッグ出力
         if isinstance(fun, str):
-            logger.debug(' ' * print_indent + f'Femtet API:{fun}, args:{args}, kwargs:{kwargs}')
+            logger.debug(
+                " " * print_indent + f"Femtet API:{fun}, args:{args}, kwargs:{kwargs}"
+            )
         else:
-            logger.debug(' ' * print_indent + f'Femtet API:{fun.__name__}, args:{args}, kwargs:{kwargs}')
+            logger.debug(
+                " " * print_indent
+                + f"Femtet API:{fun.__name__}, args:{args}, kwargs:{kwargs}"
+            )
 
         # Gaudi コマンドなら Gaudi.Activate する
-        if is_Gaudi_method:  # Optimizer は Gogh に触らないので全部にこれをつけてもいい気がする
+        if (
+            is_Gaudi_method
+        ):  # Optimizer は Gogh に触らないので全部にこれをつけてもいい気がする
             try:
                 # まず Gaudi にアクセスできるか
                 gaudi_accessible = self._check_gaudi_accessible()
                 if gaudi_accessible:
                     # Gaudi にアクセスできるなら Gaudi を Activate する
-                    fun = self._construct_femtet_api(fun)  # (str) -> Callable
-                    if fun.__name__ != 'Activate':
+                    fun = self._construct_femtet_api(fun)  # str | callable -> callable
+                    if fun.__name__ != "Activate":
                         # 再帰ループにならないように
                         self._call_femtet_api(
                             self.Femtet.Gaudi.Activate,
                             False,  # None 以外なら何でもいい
                             Exception,
-                            'Gaudi のオープンに失敗しました',
-                            print_indent=print_indent + 1
+                            'Failed to Femtet.Gaudi.Activate()',
+                            print_indent=print_indent + 1,
                         )
 
                 else:
@@ -427,18 +661,25 @@ class FemtetInterface(FEMInterface):
 
             # gaudi_accessible なので関数が何であろうが安全にアクセスはできる
             if isinstance(fun, str):
-                fun = self._construct_femtet_api(fun)  # (str) -> Callable
+                fun = self._construct_femtet_api(fun)  # str | callable -> callable
 
             # 解析結果を開いた状態で Gaudi.Activate して ReExecute する場合、ReExecute の前後にアクティブ化イベントが必要
             # さらに、プロジェクトツリーが開いていないとアクティブ化イベントも意味がないらしい。
-            if fun.__name__ == 'ReExecute':
-                if self.open_result_with_gui or self.parametric_output_indexes_use_as_objective:
+            if fun.__name__ == "ReExecute":
+                if (
+                    self.open_result_with_gui
+                    or self.parametric_output_indexes_use_as_objective
+                ):
                     _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:
+                if (
+                    self.open_result_with_gui
+                    or self.parametric_output_indexes_use_as_objective
+                ):
                     _post_activate_message(self.Femtet.hWnd)
             else:
+                import sys
                 returns = fun(*args, **kwargs)
 
         # API の実行に失敗
@@ -449,7 +690,7 @@ class FemtetInterface(FEMInterface):
                 returns = return_value_if_failed
             else:
                 returns = [return_value_if_failed] * (ret_for_check_idx + 1)
-        logger.debug(' ' * print_indent + f'Femtet API result:{returns}')
+        logger.debug(" " * print_indent + f"Femtet API result:{returns}")
 
         # チェックすべき値の抽出
         if ret_for_check_idx is None:
@@ -468,25 +709,37 @@ class FemtetInterface(FEMInterface):
             if self.femtet_is_alive():
                 # 生きていてもここにきているなら
                 # 指定された Exception を送出する
-                logger.debug(' ' * print_indent + error_message)
+                logger.debug(" " * print_indent + error_message)
                 raise if_error(error_message)
 
             # 死んでいるなら再起動
             else:
                 # 再起動試行回数の上限に達していたら諦める
-                logger.debug(' ' * print_indent + f'現在の Femtet 再起動回数: {recourse_depth}')
+                logger.debug(
+                    " " * print_indent + f"現在の Femtet 再起動回数: {recourse_depth}"
+                )
                 if recourse_depth >= self.max_api_retry:
-                    raise Exception(Msg.ERR_FEMTET_CRASHED_AND_RESTART_FAILED)
+                    raise Exception(
+                        Msg.F_ERR_FEMTET_CRASHED_AND_RESTART_FAILED(
+                            fun.__name__
+                        )
+                    )
 
                 # 再起動
-                logger.warn(' ' * print_indent + Msg.WARN_FEMTET_CRASHED_AND_TRY_RESTART)
+                logger.warning(
+                    " " * print_indent + Msg.F_WARN_FEMTET_CRASHED_AND_TRY_RESTART(
+                        fun.__name__
+                    )
+                )
                 CoInitialize()
-                self.connect_femtet(connect_method='new')
+                self.connect_femtet(connect_method="new")
                 self.open(self.femprj_path, self.model_name)
 
                 # 状態を復元するために一度変数を渡して解析を行う（fun.__name__がSolveなら2度手間だが）
-                logger.info(' ' * print_indent + Msg.INFO_FEMTET_CRASHED_AND_RESTARTED)
-                self.update(self.parameters)
+                logger.info(" " * print_indent + Msg.INFO_FEMTET_CRASHED_AND_RESTARTED)
+
+                self.update_parameter(self.current_prm_values)
+                self.update()
 
                 # 与えられた API の再帰的再試行
                 return self._call_femtet_api(
@@ -499,90 +752,27 @@ class FemtetInterface(FEMInterface):
                     args,
                     kwargs,
                     recourse_depth + 1,
-                    print_indent + 1
+                    print_indent + 1,
                 )
 
     def femtet_is_alive(self) -> bool:
         """Returns connected femtet process is existing or not."""
-        return _get_pid(self.Femtet.hWnd) > 0  # hWnd の値はすでに Femtet が終了している場合は 0
-
-    def open(self, femprj_path: str, model_name: str or None = None) -> None:
-        """Open specific analysis model with connected Femtet."""
-
-        # 引数の処理
-        self.femprj_path = os.path.abspath(femprj_path)
-        self.model_name = model_name
-        # 開く
-        if self.model_name is None:
-            result = self.Femtet.LoadProject(
-                self.femprj_path,
-                True
-            )
-        else:
-            result = self.Femtet.LoadProjectAndAnalysisModel(
-                self.femprj_path,
-                self.model_name,
-                True
-            )
-        if not result:
-            self.Femtet.ShowLastError()
-
-    def _connect_and_open_femtet(self):
-        """Connects to a Femtet process and open the femprj.
-
-        This function is for establishing a connection with Femtet and opening the specified femprj file.
 
-        At the beginning of the function, we check if femprj_path is specified.
-
-        If femprj_path is specified, first connect to Femtet using the specified connection method. Then, if the project path of the connected Femtet is different from the specified femprj_path, open the project using the open function. Also, if model_name is specified, the project will be opened using the open function even if the Femtet analysis model name is different from the specified model_name.
-
-        On the other hand, if femprj_path is not specified, an error message will be displayed stating that femprj_path must be specified in order to use the "new" connection method. If the connection method is not "new", it will try to connect to an existing Femtet instance. If the connection is successful, the project path and analysis model name of the Femtet instance will be stored as femprj_path and model_name.
-
-        """
-
-        logger.info(f'Try to connect Femtet (method: "{self.connect_method}").')
-        logger.info(f'│ femprj: {self.femprj_path if self.femprj_path is not None else "not specified."}')
-        logger.info(f'│ model: {self.model_name if self.femprj_path is not None else "not specified."}')
+        try:
+            hwnd = self.Femtet.hWnd
+        except (com_error, AttributeError):
+            return False
 
-        # femprj が指定されている
-        if self.femprj_path is not None:
-            # 指定された方法で接続してみて
-            # 接続した Femtet と指定された femprj 及び model が異なれば
-            # 接続した Femtet で指定された femprj 及び model を開く
-            self.connect_femtet(self.connect_method)
+        if hwnd == 0:
+            return False
 
-            # プロジェクトの相違をチェック
-            if self.Femtet.ProjectPath != self.femprj_path:
-                self.open(self.femprj_path, self.model_name)
+        pid = _get_pid(hwnd)
 
-            # モデルが指定されていればその相違もチェック
-            if self.model_name is not None:
-                if self.Femtet.AnalysisModelName != self.model_name:
-                    self.open(self.femprj_path, self.model_name)
+        return pid > 0
 
-        # femprj が指定されていない
-        else:
-            # かつ new だと解析すべき femprj がわからないのでエラー
-            if (
-                    (self.connect_method == 'new')
-                    and (not self.allow_without_project)
-            ):
-                raise RuntimeError(Msg.ERR_NEW_FEMTET_BUT_NO_FEMPRJ)
+    # ===== model check and solve =====
 
-            # さらに auto の場合は Femtet が存在しなければ new と同じ挙動になるので同様の処理
-            if (
-                    (self.connect_method == 'auto')
-                    and (len(_get_pids(process_name='Femtet.exe')) == 0)
-                    and (not self.allow_without_project)
-            ):
-                raise RuntimeError(Msg.ERR_NEW_FEMTET_BUT_NO_FEMPRJ)
-            self.connect_femtet(self.connect_method)
-
-        # 最終的に接続した Femtet の femprj_path と model を インスタンスに戻す
-        self.femprj_path = self.Femtet.Project
-        self.model_name = self.Femtet.AnalysisModelName
-
-    def check_param_value(self, param_name):
+    def _check_param_and_raise(self, param_name) -> None:
         """Check param_name is set in femprj file or not.
 
         Note:
@@ -595,45 +785,53 @@ class FemtetInterface(FEMInterface):
             try:
                 variable_names = self.Femtet.GetVariableNames_py()
             except AttributeError as e:
-                logger.error('================')
-                logger.error(Msg.ERR_CANNOT_ACCESS_API + 'GetVariableNames_py')
+                logger.error("================")
+                logger.error(Msg.ERR_CANNOT_ACCESS_API + "GetVariableNames_py")
                 logger.error(Msg.CERTIFY_MACRO_VERSION)
-                logger.error('================')
+                logger.error("================")
                 raise e
-                
+
             if variable_names is not None:
                 if param_name in variable_names:
                     return self.Femtet.GetVariableValue(param_name)
             message = Msg.ERR_NO_SUCH_PARAMETER_IN_FEMTET
-            logger.error('================')
+            logger.error("================")
             logger.error(message)
-            logger.error(f'`{param_name}` not in {variable_names}')
-            logger.error('================')
+            logger.error(f"`{param_name}` not in {variable_names}")
+            logger.error("================")
             raise RuntimeError(message)
         else:
             return None
 
-    def update_parameter(self, parameters: 'pd.DataFrame', with_warning=False):
+    def update_parameter(self, x: dict[str, SupportedVariableTypes], with_warning=False) -> None | list[str]:
         """Update parameter of femprj."""
-        self.parameters = parameters.copy()
+        COMInterface.update_parameter(self, x)
 
-        # 変数更新のための処理
+        # Gaudi.Activate()
         sleep(0.1)  # Gaudi がおかしくなる時がある対策
         self._call_femtet_api(
-            'self.Femtet.Gaudi.Activate',
+            "self.Femtet.Gaudi.Activate",
             True,  # 戻り値を持たないのでここは無意味で None 以外なら何でもいい
             Exception,  # 生きてるのに開けない場合
             error_message=Msg.NO_ANALYSIS_MODEL_IS_OPEN,
         )
 
+        # Version check
         major, minor, bugfix = 2023, 1, 1
+
+        # 変数一覧を取得する関数がある
         if self._version() >= _version(major, minor, bugfix):
-            # Femtet の設計変数の更新（2023.1.1 以降でマクロだけ古い場合はcheck_param_valueで引っかかっているはずなのでここはAttributeError をチェックしない）
+
+            # Femtet で定義されている変数の取得
+            # （2023.1.1 以降でマクロだけ古い場合は
+            # check_param_value で引っかかっている
+            # はずなのでここは AttributeError を
+            # チェックしない）
             existing_variable_names = self._call_femtet_api(
                 fun=self.Femtet.GetVariableNames_py,
                 return_value_if_failed=False,  # 意味がない
                 if_error=ModelError,  # 生きてるのに失敗した場合
-                error_message=f'GetVariableNames_py failed.',
+                error_message=f"GetVariableNames_py failed.",
                 is_Gaudi_method=True,
             )
 
@@ -644,57 +842,62 @@ class FemtetInterface(FEMInterface):
                 else:
                     return None
 
-            # update
-            warnings = []
-            for i, row in parameters.iterrows():
-                name = row['name']
-                value = row['value']
+            # 変数を更新
+            warning_messages = []
+            for name, value in self.current_prm_values.items():
+
+                # 渡された変数がちゃんと Femtet に定義されている
                 if name in existing_variable_names:
+
+                    # Femtet.UpdateVariable
                     self._call_femtet_api(
                         fun=self.Femtet.UpdateVariable,
                         return_value_if_failed=False,
                         if_error=ModelError,  # 生きてるのに失敗した場合
-                        error_message=Msg.ERR_FAILED_TO_UPDATE_VARIABLE + f'{value} -> {name}',
+                        error_message=Msg.ERR_FAILED_TO_UPDATE_VARIABLE
+                        + f"{value} -> {name}",
                         is_Gaudi_method=True,
                         args=(name, value),
                     )
+
+                # 渡された変数が Femtet で定義されていない
                 else:
-                    msg = f'{name} not in {self.model_name}: ' + Msg.WARN_IGNORE_PARAMETER_NOT_CONTAINED
-                    warnings.append(msg)
-                    logger.warn(msg)
+                    if self._warn_if_undefined_variable:
+                        msg = (
+                            f"{name} not in {self.model_name}: "
+                            + Msg.WARN_IGNORE_PARAMETER_NOT_CONTAINED
+                        )
+                        warning_messages.append(msg)
+                        logger.warning(msg)
 
+        # 変数一覧を取得する関数がない（チェックしない）
         else:
+
             # update without parameter check
-            warnings = []
-            for i, row in parameters.iterrows():
-                name = row['name']
-                value = row['value']
+            warning_messages = []
+            for name, value in self.current_prm_values.items():
                 self._call_femtet_api(
                     fun=self.Femtet.UpdateVariable,
                     return_value_if_failed=False,
                     if_error=ModelError,  # 生きてるのに失敗した場合
-                    error_message=Msg.ERR_FAILED_TO_UPDATE_VARIABLE + f'{value} -> {name}',
+                    error_message=Msg.ERR_FAILED_TO_UPDATE_VARIABLE
+                    + f"{value} -> {name}",
                     is_Gaudi_method=True,
                     args=(name, value),
                 )
 
         # ここでは ReExecute しない
         if with_warning:
-            return warnings
+            return warning_messages
         else:
             return None
 
-    def update_model(self, parameters: 'pd.DataFrame', with_warning=False) -> Optional[List[str]]:
+    def update_model(self) -> None:
         """Updates the analysis model only."""
 
-        self.parameters = parameters.copy()
-
-        # 変数の更新
-        warnings = self.update_parameter(parameters, with_warning)
-
         # 設計変数に従ってモデルを再構築
         self._call_femtet_api(
-            'self.Femtet.Gaudi.ReExecute',
+            "self.Femtet.Gaudi.ReExecute",
             False,
             ModelError,  # 生きてるのに失敗した場合
             error_message=Msg.ERR_RE_EXECUTE_MODEL_FAILED,
@@ -710,14 +913,12 @@ class FemtetInterface(FEMInterface):
             is_Gaudi_method=True,
         )
 
-        if with_warning:
-            return warnings or []
-
     def solve(self) -> None:
         """Execute FEM analysis."""
-        # # メッシュを切る
+
+        # メッシュを切る
         self._call_femtet_api(
-            'self.Femtet.Gaudi.Mesh',
+            "self.Femtet.Gaudi.Mesh",
             0,
             MeshError,
             Msg.ERR_MODEL_MESH_FAILED,
@@ -725,9 +926,9 @@ class FemtetInterface(FEMInterface):
         )
 
         if self.parametric_output_indexes_use_as_objective is not None:
-            from pyfemtet.opt.interface._femtet_parametric import solve_via_parametric_dll
 
-            pdt_path = self.Femtet.ResultFilePath + '.pdt'
+            # PyFemtet で保存させる pdt パスを決定する
+            pdt_path = self.Femtet.ResultFilePath + ".pdt"
 
             # 前のものが残っているとややこしいので消しておく
             if os.path.exists(pdt_path):
@@ -767,7 +968,8 @@ class FemtetInterface(FEMInterface):
                 is_Gaudi_method=True,
             )
 
-        # 次に呼ばれるはずのユーザー定義コスト関数の記述を簡単にするため先に解析結果を開いておく
+        # 次に呼ばれるはずのユーザー定義コスト関数の
+        # 記述を簡単にするため先に解析結果を開いておく
         self._call_femtet_api(
             self.Femtet.OpenCurrentResult,
             False,
@@ -777,14 +979,6 @@ class FemtetInterface(FEMInterface):
             args=(self.open_result_with_gui,),
         )
 
-    def update(self, parameters: 'pd.DataFrame') -> None:
-        """See :func:`FEMInterface.update`"""
-        self.parameters = parameters.copy()
-        self.update_model(parameters)
-        self.preprocess(self.Femtet)
-        self.solve()
-        self.postprocess(self.Femtet)
-
     def preprocess(self, Femtet):
         """A method called just before :func:`solve`.
 
@@ -807,22 +1001,14 @@ class FemtetInterface(FEMInterface):
         """
         pass
 
-    def quit(self, timeout=1, force=True):
-        """Force to terminate connected Femtet."""
-
-        _set_autosave_enabled(self._original_autosave_enabled)
-
-        if self.quit_when_destruct:
-            _exit_or_force_terminate(timeout=timeout, Femtet=self.Femtet, force=True)
-
-    def _setup_before_parallel(self, client):
-        client.upload_file(
-            self.kwargs['femprj_path'],
-            False
-        )
+    def update(self) -> None:
+        """See :func:`FEMInterface.update`"""
+        self.update_model()
+        self.preprocess(self.Femtet)
+        self.solve()
+        self.postprocess(self.Femtet)
 
-    def _version(self):
-        return _version(Femtet=self.Femtet)
+    # ===== postprocess after recording =====
 
     def _create_postprocess_args(self):
         try:
@@ -836,7 +1022,7 @@ class FemtetInterface(FEMInterface):
             jpg_content = None
 
         out = dict(
-            original_femprj_path=self.original_femprj_path,
+            original_femprj_path=self._original_femprj_path,
             model_name=self.model_name,
             pdt_file_content=file_content,
             jpg_file_content=jpg_content,
@@ -845,55 +1031,60 @@ class FemtetInterface(FEMInterface):
         return out
 
     @staticmethod
-    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')
+    def _create_path(femprj_path, model_name, trial_name, ext):
+        result_dir = femprj_path.replace(".femprj", ".Results")
+        ext = ext.removeprefix('.')
+        pdt_path = os.path.join(result_dir, model_name + f"_{trial_name}.{ext}")
         return pdt_path
 
     # noinspection PyMethodOverriding
     @staticmethod
-    def _postprocess_func(
-            trial: int,
-            df: pd.DataFrame,
-            original_femprj_path: str,
-            save_results: str,
-            model_name: str,
-            pdt_file_content=None,
-            jpg_file_content=None,
-            dask_scheduler=None
+    def _postprocess_after_recording(
+        dask_scheduler,  # must for run_on_scheduler
+        trial_name: str,
+        df: pd.DataFrame,
+        *,
+        original_femprj_path: str,
+        save_results: str,
+        model_name: str,
+        pdt_file_content=None,
+        jpg_file_content=None,
     ):
+        # FIXME: サブサンプリングの場合の処理
 
         # none なら何もしない
+        # all or optimal ならいったん保存する
         if save_results.lower() == 'none':
             return
 
-        # all or optimal ならいったん保存する
-        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)
-            with open(pdt_path, 'wb') as f:
+            pdt_path = FemtetInterface._create_path(
+                original_femprj_path, model_name, trial_name, ext='pdt')
+            with open(pdt_path, "wb") as f:
                 f.write(pdt_file_content)
 
         if jpg_file_content is not None:
-            jpg_path = os.path.join(result_dir, model_name + f'_trial{trial}.jpg')
-            with open(jpg_path, 'wb') as f:
+            jpg_path = FemtetInterface._create_path(
+                original_femprj_path, model_name, trial_name, ext='jpg')
+            with open(jpg_path, "wb") as f:
                 f.write(jpg_file_content)
 
         # optimal なら不要ファイルの削除を実行する
         if save_results.lower() == 'optimal':
             for i, row in df.iterrows():
-                if not bool(row['non_domi']):
+                if not bool(row['optimality']):
                     trial_to_remove = int(row['trial'])
-                    pdt_path_to_remove = FemtetInterface._create_pdt_path(original_femprj_path, model_name, trial_to_remove)
+                    pdt_path_to_remove = FemtetInterface._create_path(
+                        original_femprj_path, model_name, trial_to_remove, ext='pdt')
                     if os.path.isfile(pdt_path_to_remove):
                         os.remove(pdt_path_to_remove)
 
     def _create_result_file_content(self):
         """Called after solve"""
-        if self.save_pdt == 'all':
+        if self.save_pdt.lower() in ['all', 'optimal']:
             # save to worker space
-            result_dir = self.femprj_path.replace('.femprj', '.Results')
-            pdt_path = os.path.join(result_dir, self.model_name + '.pdt')
+            result_dir = self.femprj_path.replace(".femprj", ".Results")
+            pdt_path = os.path.join(result_dir, self.model_name + ".pdt")
 
             self._call_femtet_api(
                 fun=self.Femtet.SavePDT,
@@ -905,7 +1096,7 @@ class FemtetInterface(FEMInterface):
             )
 
             # convert .pdt to ByteIO and return it
-            with open(pdt_path, 'rb') as f:
+            with open(pdt_path, "rb") as f:
                 content = f.read()
             return content
 
@@ -913,8 +1104,8 @@ class FemtetInterface(FEMInterface):
             return None
 
     def _create_jpg_content(self):
-        result_dir = self.femprj_path.replace('.femprj', '.Results')
-        jpg_path = os.path.join(result_dir, self.model_name + '.jpg')
+        result_dir = self.femprj_path.replace(".femprj", ".Results")
+        jpg_path = os.path.join(result_dir, self.model_name + ".jpg")
 
         # モデル表示画面の設定
         self.Femtet.SetWindowSize(600, 600)
@@ -932,54 +1123,18 @@ class FemtetInterface(FEMInterface):
         if not os.path.exists(jpg_path):
             raise FailedToPostProcess(Msg.ERR_JPG_NOT_FOUND)
 
-        with open(jpg_path, 'rb') as f:
+        with open(jpg_path, "rb") as f:
             content = f.read()
 
         return content
 
+    # ===== others =====
 
-from win32com.client import Dispatch, constants
-
-
-class _UnPicklableNoFEM(FemtetInterface):
-
-
-    original_femprj_path = 'dummy'
-    model_name = 'dummy'
-    parametric_output_indexes_use_as_objective = None
-    kwargs = dict()
-    Femtet = None
-    quit_when_destruct = False
-
-    # noinspection PyMissingConstructor
-    def __init__(self):
-        CoInitialize()
-        self.unpicklable_member = Dispatch('FemtetMacro.Femtet')
-        self.cns = constants
-
-    def _setup_before_parallel(self, *args, **kwargs):
-        pass
-
-    def check_param_value(self, *args, **kwargs):
-        pass
-
-    def update_parameter(self, *args, **kwargs):
-        pass
-
-    def update(self, *args, **kwargs):
-        pass
-
-    def create_result_file_content(self):
-        """Called after solve"""
-
-        # save to worker space
-        with open(__file__, 'rb') as f:
-            content = f.read()
-
-        return content
+    def _get_additional_data(self) -> dict:
+        return dict(
+            femprj_path=self._original_femprj_path,
+            model_name=self.model_name,
+        )
 
-    def create_file_path(self, trial: int):
-        # return path of scheduler environment
-        here = os.path.dirname(__file__)
-        pdt_path = os.path.join(here, f'trial{trial}.pdt')
-        return pdt_path
+    def _version(self):
+        return _version(Femtet=self.Femtet)