pyfemtet 0.4.25__py3-none-any.whl → 0.5.1__py3-none-any.whl

pyfemtet/opt/_test_utils/control_femtet.py

@@ -0,0 +1,45 @@
+from time import sleep
+from subprocess import run
+from multiprocessing import Process
+from tqdm import tqdm
+from win32com.client import Dispatch
+from femtetutils import util
+
+import logging
+
+
+logger = logging.getLogger("test")
+logger.setLevel(logging.DEBUG)
+
+
+def _open_femprj(femprj_path):
+    Femtet = Dispatch("FemtetMacro.Femtet")
+    for _ in tqdm(range(5), "Wait to complete Dispatch before opening femprj..."):
+        sleep(1)
+    Femtet.LoadProject(femprj_path, True)
+
+
+def launch_femtet(femprj_path):
+    # launch Femtet externally
+    util.execute_femtet()
+    pid = util.get_last_executed_femtet_process_id()
+    for _ in tqdm(range(8), "Wait to complete Femtet launching."):
+        sleep(1)
+
+    # open femprj in a different process
+    # to release Femtet for sample program
+    if femprj_path:
+        p = Process(
+            target=_open_femprj,
+            args=(femprj_path,),
+        )
+        p.start()
+        p.join()
+
+
+def taskkill_femtet():
+    for _ in tqdm(range(3), "Wait before taskkill Femtet"):
+        sleep(1)
+    run(["taskkill", "/f", "/im", "Femtet.exe"])
+    for _ in tqdm(range(3), "Wait after taskkill Femtet"):
+        sleep(1)

pyfemtet/opt/_test_utils/hyper_sphere.py

@@ -0,0 +1,24 @@
+import numpy as np
+from numpy import sin, cos
+from pyfemtet.opt import AbstractOptimizer
+
+
+class HyperSphere(object):
+
+    def __init__(self, N):
+        self.N = N
+        self._x = np.zeros(self.N, dtype=float)
+
+    def calc(self, r, *angles):
+        _x = []
+        for i in range(self.N - 1):
+            __x = r * np.prod([sin(angles[j]) for j in range(i)])
+            __x = __x * cos(angles[i])
+            _x.append(__x)
+        _x.append(r * np.prod([sin(angles[j]) for j in range(self.N - 1)]))
+        self._x = np.array(_x)
+
+    def x(self, opt: AbstractOptimizer, index: int):
+        r, *angles = opt.get_parameter("values")
+        self.calc(r, *angles)
+        return self._x[index]

pyfemtet/opt/_test_utils/record_history.py

@@ -0,0 +1,72 @@
+import os
+import csv
+from shutil import copy
+from glob import glob
+
+import numpy as np
+import pandas as pd
+
+from pyfemtet.opt import FEMOpt
+from pyfemtet.message import encoding as ENCODING
+
+
+def find_latest_csv(dir_path=None):
+    if dir_path is None:
+        dir_path = ""
+    target = os.path.join(dir_path, "*.csv")
+    files = [(f, os.path.getmtime(f)) for f in glob(target)]
+    out = sorted(files, key=lambda files: files[1])[-1]
+    return os.path.abspath(out[0])
+
+
+def py_to_reccsv(py_path, suffix=""):
+    dst_csv_path = py_path + suffix
+    dst_csv_path = dst_csv_path.replace(f".py{suffix}", f"{suffix}.reccsv")
+    return dst_csv_path
+
+
+def record_result(src: FEMOpt or str, py_path, suffix=""):
+    """Record the result csv for `is_equal_result`."""
+
+    if isinstance(src, FEMOpt):  # get df directory
+        src_csv_path = src.history_path
+    else:
+        src_csv_path = os.path.abspath(src)
+
+    dst_csv_path = py_to_reccsv(py_path, suffix)
+    copy(src_csv_path, dst_csv_path)
+
+
+def _get_obj_from_csv(csv_path, encoding=ENCODING):
+    df = pd.read_csv(csv_path, encoding=encoding, header=2)
+    columns = df.columns
+    with open(csv_path, mode="r", encoding=encoding, newline="\n") as f:
+        reader = csv.reader(f, delimiter=",")
+        meta = reader.__next__()
+    obj_indices = np.where(np.array(meta) == "obj")[0]
+    out = df.iloc[:, obj_indices]
+    return out, columns
+
+
+def is_equal_result(ref_path, dif_path, log_path):
+    """Check the equality of two result csv files."""
+    ref_df, ref_columns = _get_obj_from_csv(ref_path)
+    dif_df, dif_columns = _get_obj_from_csv(dif_path)
+
+    with open(log_path, "a", newline="\n", encoding=ENCODING) as f:
+        f.write("\n\n===== 結果の分析 =====\n\n")
+        f.write(f"        \tref\tdif\n")
+        f.write(f"---------------------\n")
+        f.write(f"len(col)\t{len(ref_columns)}\t{len(dif_columns)}\n")
+        f.write(f"len(df) \t{len(ref_df)}\t{len(dif_df)}\n")
+        try:
+            difference = (
+                np.abs(ref_df.values - dif_df.values) / np.abs(dif_df.values)
+            ).mean()
+            f.write(f"diff    \t{int(difference*100)}%\n")
+        except Exception:
+            f.write(f"diff    \tcannot calc\n")
+
+    assert len(ref_columns) == len(dif_columns), "結果 csv の column 数が異なります。"
+    assert len(ref_df) == len(dif_df), "結果 csv の row 数が異なります。"
+    assert difference <= 0.05, "前回の結果との平均差異が 5% を超えています。"

pyfemtet/opt/interface/_femtet.py

@@ -1,8 +1,9 @@
-from typing import Optional, List
+from typing import Optional, List, Final
 
 import os
 import sys
 from time import sleep, time
+import winreg
 
 import pandas as pd
 import psutil
@@ -101,6 +102,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)
 
         # dask サブプロセスのときは femprj を更新し connect_method を new にする
         try:
@@ -142,6 +145,7 @@ class FemtetInterface(FEMInterface):
         )
 
     def __del__(self):
+        set_autosave_enabled(self._original_autosave_enabled)
         if self.quit_when_destruct:
             self.quit()
         # CoUninitialize()  # Win32 exception occurred releasing IUnknown at 0x0000022427692748
@@ -854,3 +858,37 @@ class _UnPicklableNoFEM(FemtetInterface):
         pdt_path = os.path.join(here, f'trial{trial}.pdt')
         return pdt_path
 
+
+# レジストリのパスと値の名前
+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)
+        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 _test_autosave_setting():
+
+    # 使用例
+    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)
+    print(f"AutoSave setting has been {'enabled' if new_setting else 'disabled'}.")
+
+    # 再度設定を確認する
+    after_setting = get_autosave_enabled()
+    print(f"Current AutoSave setting is {'enabled' if after_setting else 'disabled'}.")
+
+    assert new_setting == after_setting, "レジストリ編集に失敗しました。" 

pyfemtet/opt/optimizer/__init__.py

@@ -0,0 +1,12 @@
+from pyfemtet.opt.optimizer._base import AbstractOptimizer, logger, OptimizationMethodChecker
+from pyfemtet.opt.optimizer._optuna import OptunaOptimizer
+from pyfemtet.opt.optimizer._scipy import ScipyOptimizer
+from pyfemtet.opt.optimizer._scipy_scalar import ScipyScalarOptimizer
+
+__all__ = [
+    'ScipyScalarOptimizer',
+    'ScipyOptimizer',
+    'OptunaOptimizer',
+    'AbstractOptimizer',
+    'logger',
+]

pyfemtet/opt/{opt → optimizer}/_base.py

@@ -12,7 +12,7 @@ import pandas as pd
 
 # pyfemtet relative
 from pyfemtet.opt.interface import FemtetInterface
-from pyfemtet.opt._femopt_core import OptimizationStatus
+from pyfemtet.opt._femopt_core import OptimizationStatus, Objective, Constraint
 from pyfemtet.message import Msg
 from pyfemtet.opt.parameter import ExpressionEvaluator
 
@@ -135,10 +135,9 @@ class AbstractOptimizer(ABC):
         self.fem = None
         self.fem_class = None
         self.fem_kwargs = dict()
-        self.parameters: pd.DataFrame = pd.DataFrame()
         self.variables: ExpressionEvaluator = ExpressionEvaluator()
-        self.objectives: dict = dict()
-        self.constraints: dict = dict()
+        self.objectives: dict[str, Constraint] = dict()
+        self.constraints: dict[str, Constraint] = dict()
         self.entire_status = None  # actor
         self.history = None  # actor
         self.worker_status = None  # actor
@@ -155,10 +154,11 @@ class AbstractOptimizer(ABC):
         """Get x, update fem analysis, return objectives (and constraints)."""
         # interruption の実装は具象クラスに任せる
 
-        # x の更新
-        prm_names = self.variables.get_parameter_names()
-        for name, value in zip(prm_names, x):
-            self.variables.variables[name].value = value
+        if isinstance(x, np.float64):
+            x = np.array([x])
+
+        # Optimizer の x の更新
+        self.set_parameter_values(x)
 
         logger.info('---------------------')
         logger.info(f'input: {x}')
@@ -237,7 +237,28 @@ class AbstractOptimizer(ABC):
             ValueError: If an invalid format is provided.
 
         """
-        return self.variables.get_variables(format=format)
+        return self.variables.get_variables(format=format, filter_parameter=True)
+
+    def set_parameter(self, params: dict) -> 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.
+
+        """
+        for name, value in params.items():
+            self.variables.variables[name].value = value
+        self.variables.evaluate()
+
+    def set_parameter_values(self, values: np.ndarray) -> None:
+        """Update parameter with values.
+
+        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)})
 
     def _check_interruption(self):
         """"""

pyfemtet/opt/{opt → optimizer}/_optuna.py

@@ -11,8 +11,8 @@ from optuna.trial import TrialState
 from optuna.study import MaxTrialsCallback
 
 # pyfemtet relative
-from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
+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
 
@@ -54,7 +54,7 @@ class OptunaOptimizer(AbstractOptimizer):
         self.additional_initial_parameter = []
         self.additional_initial_methods = add_init_method if hasattr(add_init_method, '__iter__') else [add_init_method]
         self.method_checker = OptunaMethodChecker(self)
-        self.parameter_constraints = []
+        self._do_monkey_patch = False
 
     def _objective(self, trial):
 
@@ -114,14 +114,14 @@ class OptunaOptimizer(AbstractOptimizer):
 
         # 拘束 attr の更新
         if len(self.constraints) > 0:
-            _c = []  # 非正なら OK
+            _c = []  # <= 0 is feasible
             for (name, cns), c_value in zip(self.constraints.items(), c):
                 lb, ub = cns.lb, cns.ub
                 if lb is not None:  # fun >= lb  <=>  lb - fun <= 0
                     _c.append(lb - c_value)
                 if ub is not None:  # ub >= fun  <=>  fun - ub <= 0
                     _c.append(c_value - ub)
-            trial.set_user_attr('constraint', _c)
+            trial.set_user_attr('constraints', _c)
 
         # 中断の確認 (解析中に interrupt されている場合対策)
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
@@ -134,8 +134,8 @@ class OptunaOptimizer(AbstractOptimizer):
 
     def _constraint(self, trial):
         # if break trial without weak constraint calculation, return 1 (as infeasible).
-        if 'constraint' in trial.user_attrs.keys():
-            return trial.user_attrs['constraint']
+        if 'constraints' in trial.user_attrs.keys():
+            return trial.user_attrs['constraints']
         else:
             _c = []
             for name, cns in self.constraints.items():
@@ -203,7 +203,7 @@ class OptunaOptimizer(AbstractOptimizer):
                 if 'LHS' in self.additional_initial_methods:
                     names = []
                     bounds = []
-                    for i, row in self.parameters.iterrows():
+                    for i, row in self.get_parameter('df').iterrows():
                         names.append(row['name'])
                         lb = row['lower_bound']
                         ub = row['upper_bound']
@@ -275,20 +275,16 @@ class OptunaOptimizer(AbstractOptimizer):
         )
 
         # monkey patch
-        if len(self.parameter_constraints) > 0:
+        if self._do_monkey_patch:
             assert isinstance(sampler, optuna.integration.BoTorchSampler), Msg.ERR_PARAMETER_CONSTRAINT_ONLY_BOTORCH
 
-            from pyfemtet.opt.opt._optuna_botorch_helper import OptunaBotorchWithParameterConstraintMonkeyPatch
-            mp = OptunaBotorchWithParameterConstraintMonkeyPatch(
+            from pyfemtet.opt.optimizer._optuna_botorchsampler_parameter_constraint_helper import do_patch
+
+            do_patch(
                 study,
-                self,
+                self.constraints,
+                self
             )
-            for p_cns in self.parameter_constraints:
-                fun = p_cns['fun']
-                prm_args = p_cns['prm_args']
-                kwargs = p_cns['kwargs']
-                mp.add_nonlinear_constraint(fun, prm_args, kwargs)
-            mp.do_monkey_patch()
 
         # run
         study.optimize(
@@ -296,18 +292,3 @@ class OptunaOptimizer(AbstractOptimizer):
             timeout=self.timeout,
             callbacks=self.optimize_callbacks,
         )
-
-    def add_parameter_constraints(
-            self,
-            fun,
-            prm_args=None,
-            kwargs=None
-    ):
-        kwargs = kwargs if kwargs is not None else {}
-        self.parameter_constraints.append(
-            dict(
-                fun=fun,
-                prm_args=prm_args,
-                kwargs=kwargs,
-            )
-        )