pyfemtet 1.0.0b0__tar.gz → 1.0.1__tar.gz

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyfemtet
-Version: 1.0.0b0
+Version: 1.0.1
 Summary: Design parameter optimization using Femtet.
 License: MIT
 Author: kazuma.naito

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/_util/df_util.py

@@ -1,3 +1,4 @@
+from math import isnan
 import pandas as pd
 
 
@@ -9,8 +10,24 @@ __all__ = [
 
 def get_index(df, equality_filters):
     # フィルタ条件に一致する行のインデックスを取得
+
+    # na との == での比較は常に False なので別処理するために別リストを作る
+    want_na_keys = []
+    for key, value in equality_filters.items():
+        if isinstance(value, float):
+            if isnan(value):
+                want_na_keys.append(key)
+    [equality_filters.pop(key) for key in want_na_keys]
+
+    # na 以外の比較
     # noinspection PyUnresolvedReferences
-    return (df[list(equality_filters.keys())] == pd.Series(equality_filters)).all(axis=1)
+    out: pd.Series = (df[list(equality_filters.keys())] == pd.Series(equality_filters)).all(axis=1)
+
+    # na との比較
+    for key in want_na_keys:
+        out = out & df[key].isna()
+
+    return out
 
 
 def get_partial_df(df: pd.DataFrame, equality_filters: dict):

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/_util/helper.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 from typing import Callable
+
+import string
+import secrets
 import warnings
 from time import time, sleep
 from threading import Thread
@@ -10,6 +13,7 @@ from pyfemtet._i18n import _
 __all__ = [
     'float_',
     'time_counting',
+    'generate_random_id',
 ]
 
 
@@ -92,3 +96,8 @@ def time_counting(
         warning_message,
         warning_fun,
     )
+
+
+def generate_random_id(length: int = 16) -> str:
+    alphabet = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(alphabet) for _ in range(length))

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/femopt.py

@@ -29,6 +29,19 @@ logger = get_module_logger('opt.femopt', False)
 
 
 class FEMOpt:
+    """
+    A class to manage finite element method (FEM) optimization using a specified optimizer and FEM interface.
+
+    Attributes:
+        opt (AbstractOptimizer): The optimizer instance to be used for optimization.
+        monitor_info (dict[str, str | int | None]): Dictionary to store monitoring information such as host and port.
+
+    Args:
+        fem (AbstractFEMInterface, optional): An instance of a FEM interface. Defaults to None, in which case a FemtetInterface is used.
+        opt (AbstractOptimizer, optional): An optimizer instance. Defaults to None, in which case OptunaOptimizer is used.
+
+    """
+
     opt: AbstractOptimizer
 
     def __init__(

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/history/_history.py

@@ -18,6 +18,7 @@ import pandas as pd
 import pyfemtet
 
 from pyfemtet._i18n import *
+from pyfemtet._util.helper import generate_random_id
 from pyfemtet._util.df_util import *
 from pyfemtet._util.dask_util import *
 from pyfemtet._util.str_enum import StrEnum
@@ -43,7 +44,10 @@ __all__ = [
     'MAIN_FILTER',
 ]
 
-MAIN_FILTER: dict = {'sub_fidelity_name': MAIN_FIDELITY_NAME}
+MAIN_FILTER: dict = {
+    'sub_fidelity_name': MAIN_FIDELITY_NAME,
+    'sub_sampling': float('nan')
+}
 
 
 logger = get_module_logger('opt.history', False)
@@ -126,9 +130,10 @@ class DataFrameWrapper:
 
     __df: pd.DataFrame
     _lock_name = 'edit-df'
-    _dataset_name = 'df'
+    _dataset_name: str
 
     def __init__(self, df: pd.DataFrame):
+        self._dataset_name = 'df-' + generate_random_id()
         self.set_df(df)
 
     def __len__(self):
@@ -1053,6 +1058,14 @@ class Records:
 
         with self.df_wrapper.lock_if_not_locked:
 
+            # check trial_id is filled
+            trial_processed = False
+            if processing_df['trial_id'].notna().all():
+                id_to_n: dict = {tid: i + 1 for i, tid
+                                 in enumerate(processing_df['trial_id'].unique())}
+                processing_df['trial'] = processing_df['trial_id'].map(id_to_n)
+                trial_processed = True
+
             # update main fidelity
             equality_filters = MAIN_FILTER
             mgr = EntireDependentValuesCalculator(
@@ -1062,13 +1075,13 @@ class Records:
             )
             mgr.update_optimality()
             mgr.update_hypervolume()
-            mgr.update_trial_number()
+            if not trial_processed:
+                mgr.update_trial_number()  # per_fidelity
             pdf = mgr.partial_df
             apply_partial_df(df=processing_df, partial_df=pdf, equality_filters=equality_filters)
 
             # update sub fidelity
-            entire_df = self.df_wrapper.get_df()
-            sub_fidelity_names: list = np.unique(entire_df['sub_fidelity_name']).tolist()
+            sub_fidelity_names: list = np.unique(processing_df['sub_fidelity_name']).tolist()
             if MAIN_FIDELITY_NAME in sub_fidelity_names:
                 sub_fidelity_names.remove(MAIN_FIDELITY_NAME)
             for sub_fidelity_name in sub_fidelity_names:
@@ -1078,7 +1091,8 @@ class Records:
                     equality_filters,
                     processing_df
                 )
-                mgr.update_trial_number()
+                if not trial_processed:
+                    mgr.update_trial_number()  # per_fidelity
             pdf = mgr.partial_df
             apply_partial_df(df=processing_df, partial_df=pdf, equality_filters=equality_filters)
 

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/interface/_excel_interface/excel_interface.py

@@ -258,8 +258,6 @@ class ExcelInterface(COMInterface):
             force_override_when_load: bool = False,
     ):
 
-        show_experimental_warning("ExcelInterface")
-
         def proc_path(path_):
             if path_ is None:
                 return self._original_input_xlsm_path

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/interface/_femtet_interface/femtet_interface.py

@@ -102,8 +102,6 @@ class FemtetInterface(COMInterface):
                 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**
@@ -119,6 +117,7 @@ class FemtetInterface(COMInterface):
 
     com_members = {'Femtet': 'FemtetMacro.Femtet'}
     _show_parametric_index_warning = True  # for GUI
+    _femtet_connection_timeout = 10
 
     def __init__(
             self,
@@ -316,9 +315,9 @@ class FemtetInterface(COMInterface):
         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.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):

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/interface/_femtet_with_solidworks/femtet_with_solidworks_interface.py

@@ -20,6 +20,26 @@ if TYPE_CHECKING:
 
 
 class FemtetWithSolidworksInterface(FemtetInterface, SolidworksInterface, AbstractFEMInterface):
+    """
+    Interface class integrating Femtet and SolidWorks operations.
+
+    This class combines the capabilities of both Femtet and SolidWorks interfaces, allowing
+    coordinated operation between simulation (Femtet) and CAD manipulation (SolidWorks).
+
+    Args:
+        sldprt_path (str): Path to the SolidWorks part file (.sldprt).
+        femprj_path (str, optional): Path to the Femtet project file (.femprj). Defaults to None.
+        model_name (str, optional): Name of the model in the project. Defaults to None.
+        connect_method (str, optional): Connection method for Femtet. Defaults to "auto".
+        save_pdt (str, optional): Specifies which data to save. Defaults to "all".
+        strictly_pid_specify (bool, optional): Whether to strictly specify parameter IDs. Defaults to True.
+        allow_without_project (bool, optional): If True, allows operation without a project file. Defaults to False.
+        open_result_with_gui (bool, optional): If True, open results with GUI. Defaults to True.
+        parametric_output_indexes_use_as_objective (dict[int, str | float], optional): Indexes for parametric output used as objectives. Defaults to None.
+        always_open_copy (bool, optional): If True, always open a copy of the project. Defaults to False.
+        close_solidworks_on_terminate (bool, optional): If True, SolidWorks will close when this object is destroyed. Defaults to False.
+        solidworks_visible (bool, optional): If True, SolidWorks will be started in visible mode. Defaults to True.
+    """
 
     def __init__(
             self,

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/interface/_solidworks_interface/solidworks_interface.py

@@ -41,6 +41,27 @@ class FileNotOpenedError(Exception):
 
 # noinspection PyPep8Naming
 class SolidworksInterface(COMInterface):
+    """
+    Interface class for interacting with SolidWorks through COM automation.
+
+    This class manages the connection and interaction with SolidWorks using its COM interface.
+    It handles initialization, visibility, and clean termination of the SolidWorks application.
+
+    Attributes:
+        swApp (CDispatch): The COM dispatch object for SolidWorks application.
+        com_members (dict): Mapping of COM member names to their interface strings.
+        sldprt_path (str): Absolute path to the SolidWorks part file (.sldprt).
+        quit_solidworks_on_terminate (bool): Whether to close SolidWorks upon object destruction.
+        solidworks_visible (bool): Whether the SolidWorks application window is visible.
+
+    Args:
+        sldprt_path (str): Path to the SolidWorks part file (.sldprt).
+        close_solidworks_on_terminate (bool, optional): If True, SolidWorks will close when this object is destroyed. Defaults to False.
+        visible (bool, optional): If True, SolidWorks will be started in visible mode. Defaults to True.
+
+    Raises:
+        AssertionError: If the specified part file does not exist.
+    """
 
     swApp: CDispatch
     com_members = {'swApp': 'SLDWORKS.Application'}

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/optimizer/_base_optimizer.py

@@ -434,6 +434,7 @@ class AbstractOptimizer:
 
         def __init__(self, opt: AbstractOptimizer):
             self.opt: AbstractOptimizer = opt
+            self.subsampling_idx: SubSampling | None = None
 
         def _preprocess(self):
             pass
@@ -460,6 +461,7 @@ class AbstractOptimizer:
                 variables_pass_to_fem: dict[str, SupportedVariableTypes],
                 history: History = None,
                 datetime_start=None,
+                trial_id=None,
         ) -> _FReturnValue:
 
             # create context
@@ -486,6 +488,8 @@ class AbstractOptimizer:
                     {obj_name: ObjectiveResult(obj, opt_.fem, float('nan'))
                      for obj_name, obj in opt_.objectives.items()}
                 )
+                record.sub_sampling = self.subsampling_idx
+                record.trial_id = trial_id
                 record.sub_fidelity_name = opt_.sub_fidelity_name
                 record.fidelity = opt_.fidelity
                 record.datetime_start = datetime_start
@@ -498,7 +502,8 @@ class AbstractOptimizer:
                     raise SkipSolve
 
                 # start solve
-                if opt_.sub_fidelity_models != MAIN_FIDELITY_NAME:
+                if opt_.sub_fidelity_name != MAIN_FIDELITY_NAME:
+                    logger.info('----------')
                     logger.info(_('fidelity: ({name})', name=opt_.sub_fidelity_name))
                 logger.info(_('input variables:'))
                 logger.info(parameters)
@@ -629,7 +634,9 @@ class AbstractOptimizer:
                 x: TrialInput,
                 x_pass_to_fem_: dict[str, SupportedVariableTypes],
                 opt_: AbstractOptimizer | None = None,
+                trial_id: str =None,
         ) -> _FReturnValue | None:
+            """Nothing will be raised even if infeasible."""
 
             vm = self.opt.variable_manager
 
@@ -643,32 +650,40 @@ class AbstractOptimizer:
             # if opt_ is not self, update variable manager
             opt_.variable_manager = vm
 
-            # preprocess
-            self._preprocess()
+            # noinspection PyMethodParameters
+            class Process:
+                def __enter__(self_):
+                    # preprocess
+                    self._preprocess()
 
-            # declare output
-            f_return = None
+                def __exit__(self_, exc_type, exc_val, exc_tb):
+                    # postprocess
+                    self._postprocess()
 
-            # start solve
-            datetime_start = datetime.datetime.now()
-            try:
-                f_return = self._solve_or_raise(
-                    opt_, x, x_pass_to_fem_, self.opt.history, datetime_start
-                )
+            with Process():
 
-            except HardConstraintViolation as e:
-                self._hard_constraint_handling(e)
+                # declare output
+                f_return = None
 
-            except _HiddenConstraintViolation as e:
-                self._hidden_constraint_handling(e)
+                # start solve
+                datetime_start = datetime.datetime.now()
+                try:
+                    f_return = self._solve_or_raise(
+                        opt_, x, x_pass_to_fem_, self.opt.history,
+                        datetime_start, trial_id
+                    )
 
-            except SkipSolve as e:
-                self._skip_handling(e)
+                except HardConstraintViolation as e:
+                    self._hard_constraint_handling(e)
 
-            else:
-                self._if_succeeded(f_return)
+                except _HiddenConstraintViolation as e:
+                    self._hidden_constraint_handling(e)
 
-            self._postprocess()
+                except SkipSolve as e:
+                    self._skip_handling(e)
+
+                else:
+                    self._if_succeeded(f_return)
 
             # check interruption
             self.opt._check_and_raise_interruption()
@@ -799,8 +814,19 @@ class AbstractOptimizer:
         # noinspection PyMethodParameters
         class LoggingOutput:
             def __enter__(self_):
-                self_.count = len(self.history.get_df()) + 1
-                logger.info(f'▼▼▼▼▼ solve {self_.count} start ▼▼▼▼▼')
+                df = self.history.get_df(
+                    equality_filters=MAIN_FILTER
+                )
+                self_.count = len(df) + 1
+
+                succeeded_count = len(df[df['state'] == TrialState.succeeded])
+                succeeded_text = _(
+                    en_message='{succeeded_count} succeeded trials',
+                    jp_message='成功した試行数: {succeeded_count}',
+                    succeeded_count=succeeded_count,
+                )
+
+                logger.info(f'▼▼▼▼▼ solve {self_.count} ({succeeded_text}) start ▼▼▼▼▼')
 
             def __exit__(self_, exc_type, exc_val, exc_tb):
                 logger.info(f'▲▲▲▲▲ solve {self_.count} end ▲▲▲▲▲\n')

pyfemtet-1.0.1/pyfemtet/opt/optimizer/optuna_optimizer/_optuna_attribute.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TypedDict, Sequence
+
+import optuna.trial
+
+from pyfemtet.opt.problem.problem import *
+from pyfemtet.opt.history import *
+from pyfemtet.opt.optimizer._base_optimizer import *
+
+
+class OptunaAttribute:
+    """Manage optuna user attribute.
+
+    By `set_user_attr_to_trial`,
+        key (str):
+            {sub_fidelity_name}(_{subsampling_idx})
+        value (dict):
+            fidelity: ...
+            internal_y_values: ...
+            violation_values: ...
+            pf_state: ...
+
+    """
+    class AttributeStructure(TypedDict):
+        fidelity: Fidelity | None
+        internal_y_values: Sequence[float] | None
+        violation_values: Sequence[float] | None
+        pf_state: TrialState | None
+
+    def __init__(
+            self,
+            opt: AbstractOptimizer,
+            subsampling_idx: SubSampling | None = None,
+    ):
+        # key
+        self.sub_fidelity_name: str = opt.sub_fidelity_name
+        self.subsampling_idx: SubSampling | None = subsampling_idx
+        # value
+        self.fidelity: Fidelity = opt.fidelity
+        self.y_values: Sequence[float] | None = None
+        self.v_values: Sequence[float] | None = None
+        self.pf_state: TrialState | None = None
+
+    @property
+    def key(self) -> str:
+        key = self.sub_fidelity_name
+        if self.subsampling_idx is not None:
+            key += f'_{self.subsampling_idx}'
+        return key
+
+    @property
+    def value(self) -> AttributeStructure:
+        out = self.AttributeStructure(
+            fidelity=self.fidelity,
+            internal_y_values=self.y_values,
+            violation_values=self.v_values,
+            pf_state=self.pf_state,
+        )
+        return out
+
+    def set_user_attr_to_trial(self, trial: optuna.trial.Trial):
+        trial.set_user_attr(self.key, self.value)

{pyfemtet-1.0.0b0 → pyfemtet-1.0.1}/pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py

@@ -39,6 +39,37 @@ warnings.filterwarnings('ignore', 'Argument ``constraints_func`` is an experimen
 
 
 class OptunaOptimizer(AbstractOptimizer):
+    """
+    An optimizer class utilizing Optuna for hyperparameter optimization.
+
+    This class provides an interface to conduct optimization studies using Optuna.
+    It manages the study lifecycle, sampler configuration, and trial execution.
+
+    Attributes:
+        study_name (str): Name of the Optuna study.
+        storage (str | optuna.storages.BaseStorage): Storage URL or object for the Optuna study.
+        storage_path (str): Path to the Optuna study storage.
+        current_trial (optuna.trial.Trial | None): The current Optuna trial being evaluated.
+        sampler_class (type[optuna.samplers.BaseSampler]): The class of the Optuna sampler to use.
+        sampler_kwargs (dict): Keyword arguments to initialize the sampler.
+        n_trials (int | None): Number of trials to run in the study.
+        timeout (float | None): Maximum time allowed for the optimization.
+        callbacks (list): List of callback functions to invoke during optimization.
+
+    Args:
+        sampler_class (type[optuna.samplers.BaseSampler], optional): The sampler class for suggesting parameter values. Defaults to TPESampler if None.
+        sampler_kwargs (dict[str, ...], optional): Dictionary of keyword arguments for the sampler. Defaults to an empty dictionary.
+
+    Raises:
+        None
+
+    Examples:
+        >>> optimizer = OptunaOptimizer()
+        >>> optimizer.n_trials = 100
+        >>> optimizer.timeout = 600
+        >>> # Further configuration and usage...
+    """
+
     # system
     study_name = 'pyfemtet-study'
     storage: str | optuna.storages.BaseStorage
@@ -122,7 +153,7 @@ class OptunaOptimizer(AbstractOptimizer):
 
             y, dict_y_internal, c, record = f_return
 
-            # convert constraint to **sorted** violation
+            # convert constraint to **sorted 1-d array** violation
             assert len(c) == len(self.opt_.constraints)
             v = {}
             for cns_name, cns in self.opt_.constraints.items():
@@ -139,10 +170,7 @@ class OptunaOptimizer(AbstractOptimizer):
 
         def _postprocess(self):
             # update trial attribute
-            self.opt.current_trial.set_user_attr(
-                self.optuna_attr.key,
-                self.optuna_attr.value,
-            )
+            self.optuna_attr.set_user_attr_to_trial(self.opt.current_trial)
 
     def _create_infeasible_constraints(self, opt_: AbstractOptimizer = None) -> tuple:
         opt_ = opt_ if opt_ is not None else self
@@ -155,9 +183,9 @@ class OptunaOptimizer(AbstractOptimizer):
         return tuple(1e9 * np.ones(count, dtype=np.float64))
 
     def _constraint(self, trial: optuna.trial.FrozenTrial):
-        key = OptunaAttribute(self).key
-        value = trial.user_attrs[key]
-        return OptunaAttribute.get_violation_from_trial_attr(value)
+        main_key = OptunaAttribute(self).key
+        user_attribute: OptunaAttribute.AttributeStructure = trial.user_attrs[main_key]
+        return user_attribute['violation_values']
 
     def _objective(self, trial: optuna.trial.Trial):
 
@@ -226,9 +254,9 @@ class OptunaOptimizer(AbstractOptimizer):
 
             # To avoid trial FAILED with hard constraint
             # violation, check pf_state and raise TrialPruned.
-            key = OptunaAttribute(self).key
-            value = trial.user_attrs[key]
-            state = OptunaAttribute.get_pf_state_from_trial_attr(value)
+            main_key = OptunaAttribute(self).key
+            user_attribute: OptunaAttribute.AttributeStructure = trial.user_attrs[main_key]
+            state: TrialState = user_attribute['pf_state']
             if state in [
                 TrialState.hard_constraint_violation,
                 TrialState.model_error,
@@ -245,9 +273,6 @@ class OptunaOptimizer(AbstractOptimizer):
 
             return y_internal
 
-        if get_client() is None:
-            self.history.save()
-
     def _get_callback(self, n_trials: int):
 
         # restart である場合、追加 N 回と見做す
@@ -587,16 +612,16 @@ def debug_1():
     _opt.add_parameter('x1', 1, -1, 1, step=0.1)
     _opt.add_parameter('x2', 1, -1, 1, step=0.1)
     _opt.add_categorical_parameter('x3', 'a', choices=['a', 'b', 'c'])
-    _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_fem, _opt))
-    _opt.add_objective('obj1', _parabola, args=(_fem, _opt))
-    # _opt.add_objective('obj2', _parabola2, args=(_fem, _opt))
+    # _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_opt,))
+    _opt.add_objective('obj1', _parabola, args=(_opt,))
+    # _opt.add_objective('obj2', _parabola2, args=(_opt,))
 
     # # ===== sub-fidelity =====
     # __fem = NoFEM()
     # __opt = SubFidelityModel()
     # __opt.fem = __fem
-    # __opt.add_objective('obj1', _parabola, args=(__fem, __opt))
-    # __opt.add_objective('obj2', _parabola2, args=(__fem, __opt))
+    # __opt.add_objective('obj1', _parabola, args=(__opt,))
+    # # __opt.add_objective('obj2', _parabola2, args=(__opt,))
     #
     # _opt.add_sub_fidelity_model(name='low-fidelity', sub_fidelity_model=__opt, fidelity=0.5)
     #
@@ -622,6 +647,96 @@ def debug_1():
     _opt.history.save()
 
 
+def debug_1s():
+    # from pyfemtet.opt.optimizer.optuna_optimizer.pof_botorch.pof_botorch_sampler import
+    # sampler = PoFBoTorchSampler(
+    #     n_startup_trials=5,
+    #     seed=42,
+    #     constraints_func=self._constraint,
+    #     pof_config=PoFConfig(
+    #         # consider_pof=False,
+    #         # feasibility_cdf_threshold='mean',
+    #     ),
+    #     partial_optimize_acqf_kwargs=PartialOptimizeACQFConfig(
+    #         # gen_candidates='scipy',
+    #         timeout_sec=5.,
+    #         # method='SLSQP'  # 'COBYLA, COBYQA, SLSQP or trust-constr
+    #         tol=0.1,
+    #         # scipy_minimize_kwargs=dict(),
+    #     ),
+    # )
+    # from optuna_integration import BoTorchSampler
+    # sampler = BoTorchSampler(n_startup_trials=5)
+
+    os.chdir(os.path.dirname(__file__))
+
+    def _parabola(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        d = _opt.get_variables()
+        x1 = d['x1']
+        x2 = d['x2']
+        # if _cns(_fem, _opt) < 0:
+        #     raise PostProcessError
+        return x1 ** 2 + x2 ** 2
+
+    def _parabola2(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        x = _opt.get_variables('values')
+        return ((x - 0.1) ** 2).sum()
+
+    def _cns(_fem: AbstractFEMInterface, _opt: AbstractOptimizer) -> float:
+        x = _opt.get_variables('values')
+        return x[0]
+
+    _fem = NoFEM()
+    _opt = OptunaOptimizer()
+    _opt.fem = _fem
+
+    # _opt.sampler = optuna.samplers.RandomSampler(seed=42)
+    _opt.seed = 42
+    _opt.sampler_class = optuna.samplers.TPESampler
+    # _opt.sampler_class = optuna.samplers.RandomSampler
+    _opt.sampler_kwargs = dict(
+        n_startup_trials=5,
+    )
+    _opt.n_trials = 10
+
+    _opt.add_parameter('x1', 1, -1, 1, step=0.1)
+    _opt.add_parameter('x2', 1, -1, 1, step=0.1)
+    _opt.add_categorical_parameter('x3', 'a', choices=['a', 'b', 'c'])
+    # _opt.add_constraint('cns', _cns, lower_bound=-0.9, args=(_opt,))
+    _opt.add_objective('obj1', _parabola, args=(_opt,))
+    # _opt.add_objective('obj2', _parabola2, args=(_opt,))
+
+    # ===== sub-fidelity =====
+    __fem = NoFEM()
+    __opt = SubFidelityModel()
+    __opt.fem = __fem
+    __opt.add_objective('obj1', _parabola, args=(__opt,))
+    # __opt.add_objective('obj2', _parabola2, args=(__opt,))
+
+    _opt.add_sub_fidelity_model(name='low-fidelity', sub_fidelity_model=__opt, fidelity=0.5)
+
+    def _solve_condition(_history: History):
+
+        sub_fidelity_df = _history.get_df(
+            {'sub_fidelity_name': 'low-fidelity'}
+        )
+        idx = sub_fidelity_df['state'] == TrialState.succeeded
+        pdf = sub_fidelity_df[idx]
+
+        return len(pdf) % 5 == 0
+
+    _opt.set_solve_condition(_solve_condition)
+
+    # _opt.history.path = 'restart-test.csv'
+    _opt.run()
+
+    # import plotly.express as px
+    # _df = _opt.history.get_df()
+    # px.scatter_3d(_df, x='x1', y='x2', z='obj', color='fidelity', opacity=0.5).show()
+
+    _opt.history.save()
+
+
 def substrate_size(Femtet):
     """基板のXY平面上での専有面積を計算します。"""
     substrate_w = Femtet.GetVariableValue('substrate_w')
@@ -669,10 +784,13 @@ def debug_3():
     opt.add_parameter(name="substrate_d", initial_value=60, lower_bound=34, upper_bound=60)
 
     opt.n_trials = 5
-    opt.history.path = os.path.join(os.path.dirname(__file__), 'femtet-test.csv')
+    opt.history.path = os.path.join(os.path.dirname(__file__), 'femtet-test-2.csv')
 
     opt.run()
 
 
 if __name__ == '__main__':
+    debug_1()
+    debug_1s()
+    debug_2()
     debug_3()