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

pyfemtet/opt/optimizer/_optuna_botorchsampler_parameter_constraint_helper.py

@@ -0,0 +1,325 @@
+from typing import Callable
+from functools import partial
+
+import numpy as np
+
+import torch
+from torch import Tensor
+
+from optuna.study import Study
+from optuna.trial import Trial
+from optuna._transform import _SearchSpaceTransform
+
+from botorch.acquisition import AcquisitionFunction
+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 time import time
+
+
+__all__ = ['do_patch']
+
+
+BotorchConstraint = Callable[[Tensor], Tensor]
+
+
+def do_patch(
+    study: Study,
+    constraints: dict[str, Constraint],
+    opt: OptunaOptimizer,
+):
+    """BoTorchSampler の optimize_acqf をパッチし、パラメータ拘束が実施できるようにします。
+
+    Args:
+        study (Study): Optuna study. Use to calculate bounds.
+        constraints (dict[str, Constraint]): Constraints.
+        opt (OptunaOptimizer): OptunaOptimizer.
+    """
+    import optuna_integration
+    target_fun = optuna_integration.botorch.optimize_acqf
+    new_fun: callable = OptimizeReplacedACQF(target_fun)
+    new_fun.set_constraints(list(constraints.values()))
+    new_fun.set_study(study)
+    new_fun.set_opt(opt)
+    optuna_integration.botorch.optimize_acqf = new_fun
+
+
+class GeneralFunctionWithForwardDifference(torch.autograd.Function):
+    """自作関数を pytorch で自動微分するためのクラスです。
+
+    ユーザー定義関数を botorch 形式に変換する過程で微分の計算ができなくなるのでこれが必要です。
+    """
+
+    @staticmethod
+    def forward(ctx, f, xs):
+        ys = f(xs)
+        ctx.save_for_backward(xs, ys)
+        ctx.f = f
+        return ys
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        xs, ys = ctx.saved_tensors
+        f = ctx.f
+        dx = 0.001  # 入力は normalized なので決め打ちでよい
+        diff = []
+        xs = xs.detach()  # xs に余計な計算履歴を残さないために、detachする。
+        for i in range(len(xs)):
+            xs[i] += dx
+            diff.append(torch.sum(grad_output * (f(xs) - ys)))
+            xs[i] -= dx
+        diff = torch.tensor(diff) / dx
+        return None, diff
+
+
+class ConvertedConstraint:
+    """ユーザーが定義した Constraint を botorch で処理できる形式に変換します。
+
+    `callable()` は形状 `d` の 1 次元テンソルを受け取り、スカラーを返します。
+    """
+
+    def __init__(self, constraint: Constraint, study: Study, bound: str, opt: OptunaOptimizer):
+        self._constraint: Constraint = constraint
+        self._study = study
+        self._bound = bound
+        self._opt = opt
+
+    def __call__(self, x: Tensor) -> Tensor:  # BotorchConstraint
+        """optimize_acqf() に渡される非線形拘束関数の処理です。
+
+        Args:
+            x (Tensor): Normalized parameters. Its length is d (== len(prm)).
+
+        Returns:
+            float Tensor. >= 0 is feasible.
+
+        """
+
+        norm_x = x.detach().numpy()
+        c = evaluate_pyfemtet_cns(self._study, self._constraint, norm_x, self._opt)
+        if self._bound == 'lb':
+            return Tensor([c - self._constraint.lb])
+        elif self._bound == 'ub':
+            return Tensor([self._constraint.ub - c])
+
+
+def is_feasible(study: Study, constraints: list[Constraint], norm_x: np.ndarray, opt: OptunaOptimizer) -> bool:
+    feasible = True
+    cns: Constraint
+    for cns in constraints:
+        c = evaluate_pyfemtet_cns(study, cns, norm_x, opt)
+        if cns.lb is not None:
+            if cns.lb > c:
+                feasible = False
+                break
+        if cns.ub is not None:
+            if cns.ub < c:
+                feasible = False
+                break
+    return feasible
+
+
+def evaluate_pyfemtet_cns(study: Study, cns: Constraint, norm_x: np.ndarray, opt: OptunaOptimizer) -> float:
+    """Evaluate given constraint function by given NORMALIZED x.
+
+    Args:
+        study (Study): Optuna study. Use to detect search space from last trial's Distribution objects.
+        cns (Constraint): PyFemtet's format constraint.
+        norm_x (np.ndarray): NORMALIZED values of all parameters.
+        opt (OptunaOptimizer): PyFemtet's optimizer. Used for update values of `opt` and `fem` who may be used in `cns`.
+
+    Returns:
+        bool: feasible or not.
+    """
+    # ===== unnormalize x =====
+    search_space = study.sampler.infer_relative_search_space(study, None)
+    trans = _SearchSpaceTransform(search_space, transform_0_1=True, transform_log=False, transform_step=False)
+    params = trans.untransform(norm_x)
+
+    # ===== update OptunaOptimizer and FEMInterface who is referenced by cns =====
+
+    # opt
+    opt.set_parameter(params)
+
+    # fem
+    if cns.using_fem:
+        df_to_fem = opt.variables.get_variables(format='df', filter_pass_to_fem=True)
+        opt.fem.update_parameter(df_to_fem)
+
+    # ===== calc cns =====
+    return cns.calc(opt.fem)
+
+
+class NonlinearInequalityConstraints:
+    """botorch の optimize_acqf に parameter constraints を設定するための引数を作成します。"""
+
+    def __init__(self, study: Study, constraints: list[Constraint], opt: OptunaOptimizer):
+        self._study = study
+        self._constraints = constraints
+        self._opt = opt
+
+        self._nonlinear_inequality_constraints = []
+        cns: Constraint
+        for cns in self._constraints:
+            if cns.lb is not None:
+                cns_botorch = ConvertedConstraint(cns, self._study, 'lb', self._opt)
+                item = (lambda x: GeneralFunctionWithForwardDifference.apply(cns_botorch, x), True)
+                self._nonlinear_inequality_constraints.append(item)
+            if cns.ub is not None:
+                cns_botorch = ConvertedConstraint(cns, self._study, 'ub', self._opt)
+                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 = []
+
+        for each_num_restarts in ic_batch:
+            feasible_q_list = []
+            for each_q in each_num_restarts:
+                norm_x: np.ndarray = each_q.numpy()  # normalized parameters
+                
+                if is_feasible(self._study, self._constraints, norm_x, self._opt):
+                    feasible_q_list.append(each_q)  # Keep only feasible rows
+
+            if feasible_q_list:  # Only add if there are feasible rows
+                feasible_ic_list.append(torch.stack(feasible_q_list))
+
+        # Stack feasible conditions back into tensor format
+        if feasible_ic_list:
+            return torch.stack(feasible_ic_list)
+        else:
+            return None  # Return None if none are feasible
+
+    @staticmethod
+    def _generate_random_initial_conditions(shape):
+        # Generates random initial conditions with the same shape as ic_batch
+        return torch.rand(shape)
+
+    def _generate_feasible_initial_conditions(self, *args, **kwargs):
+        # A `num_restarts x q x d` tensor of initial conditions.
+        ic_batch = gen_batch_initial_conditions(*args, **kwargs)
+        feasible_ic_batch = self._filter_feasible_conditions(ic_batch)
+
+        while feasible_ic_batch is None:
+            # Generate new random ic_batch with the same shape
+            print('警告: gen_batch_initial_conditions() は feasible な初期値を提案しませんでした。'
+                  'パラメータ提案を探索するための初期値をランダムに選定します。')
+            random_ic_batch = self._generate_random_initial_conditions(ic_batch.shape)
+            feasible_ic_batch = self._filter_feasible_conditions(random_ic_batch)
+
+        return feasible_ic_batch
+
+    def create_kwargs(self) -> dict:
+        """
+        nonlinear_inequality_constraints:
+            非線形不等式制約を表すタプルのリスト。
+            タプルの最初の要素は、`callable(x) >= 0` という形式の制約を表す呼び出し可能オブジェクトです。
+            2 番目の要素はブール値で、点内制約の場合は `True`
+            制約は後で scipy ソルバーに渡されます。
+            この場合、`batch_initial_conditions` を渡す必要があります。
+            非線形不等式制約を使用するには、`batch_limit` を 1 に設定する必要もあります。
+                これは、`options` で指定されていない場合は自動的に行われます。
+        """
+        return dict(
+            q=1,
+            options=dict(
+                batch_limit=1,
+            ),
+            nonlinear_inequality_constraints=self._nonlinear_inequality_constraints,
+            ic_generator=self._generate_feasible_initial_conditions,
+        )
+
+
+class AcquisitionFunctionWithPenalty(AcquisitionFunction):
+    """獲得関数に infeasible 項を追加します。"""
+
+    # noinspection PyAttributeOutsideInit
+    def set_acqf(self, acqf):
+        self._acqf = acqf
+
+    # noinspection PyAttributeOutsideInit
+    def set_constraints(self, constraints: list[Constraint]):
+        self._constraints: list[Constraint] = constraints
+
+    # noinspection PyAttributeOutsideInit
+    def set_study(self, study: Study):
+        self._study: Study = study
+
+    # noinspection PyAttributeOutsideInit
+    def set_opt(self, opt: OptunaOptimizer):
+        self._opt = opt
+
+    def forward(self, X: "Tensor") -> "Tensor":
+        """
+
+        Args:
+            X (Tensor): batch_size x 1 x n_params tensor.
+
+        Returns:
+            Tensor: batch_size tensor.
+
+        """
+        base = self._acqf.forward(X)
+
+        norm_x: np.ndarray
+        for i, _norm_x in enumerate(X.detach().numpy()):
+            
+            cns: Constraint
+            for cns in self._constraints:
+                feasible = is_feasible(self._study, [cns], _norm_x[0], self._opt)
+                if not feasible:
+                    base[i] = base[i] * 0.  # ペナルティ
+                    break
+
+        return base
+
+
+class OptimizeReplacedACQF(partial):
+    """optimize_acqf をこの partial 関数に置き換えます。"""
+
+    # noinspection PyAttributeOutsideInit
+    def set_constraints(self, constraints: list[Constraint]):
+        self._constraints: list[Constraint] = constraints
+
+    # noinspection PyAttributeOutsideInit
+    def set_study(self, study: Study):
+        self._study: Study = study
+
+    # noinspection PyAttributeOutsideInit
+    def set_opt(self, opt: OptunaOptimizer):
+        self._opt = opt
+
+    def __call__(self, *args, **kwargs):
+        """置き換え先の関数の処理内容です。
+
+        kwargs を横入りして追記することで拘束を実現します。
+        """
+
+        logger.info(Msg.START_CANDIDATE_WITH_PARAMETER_CONSTRAINT)
+
+        # FEM の更新が必要な場合、時間がかかることが多いので警告を出す
+        if any([cns.using_fem for cns in self._constraints]):
+            logger.warning(Msg.WARN_UPDATE_FEM_PARAMETER_TOOK_A_LONG_TIME)
+
+        # 獲得関数に infeasible な場合のペナルティ項を追加します。
+        acqf = kwargs['acq_function']
+        new_acqf = AcquisitionFunctionWithPenalty(...)
+        new_acqf.set_acqf(acqf)
+        new_acqf.set_constraints(self._constraints)
+        new_acqf.set_study(self._study)
+        new_acqf.set_opt(self._opt)
+        kwargs['acq_function'] = new_acqf
+
+        # optimize_acqf の探索に parameter constraints を追加します。
+        nlic = NonlinearInequalityConstraints(self._study, self._constraints, self._opt)
+        kwargs.update(nlic.create_kwargs())
+
+        # replace other arguments
+        ...
+
+        return super().__call__(*args, **kwargs)

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

@@ -13,7 +13,7 @@ from scipy.optimize import minimize, OptimizeResult
 
 # pyfemtet relative
 from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
+from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.core import MeshError, ModelError, SolveError
 from pyfemtet.message import Msg
 
@@ -51,6 +51,9 @@ class StopIterationCallback:
 
 class ScipyMethodChecker(OptimizationMethodChecker):
     def check_incomplete_bounds(self, raise_error=True): return True
+    def check_seed(self, raise_error=True):
+        logger.warning(Msg.WARN_SCIPY_DOESNT_NEED_SEED)
+        return True
 
 
 class ScipyOptimizer(AbstractOptimizer):
@@ -76,8 +79,9 @@ class ScipyOptimizer(AbstractOptimizer):
 
     def _objective(self, x: np.ndarray):  # x: candidate parameter
         # update parameter
-        self.parameters['value'] = x
-        self.fem.update_parameter(self.parameters)
+        df = self.get_parameter('df')
+        df['value'] = x
+        self.fem.update_parameter(df)
 
         # strict constraints
         ...
@@ -108,13 +112,13 @@ class ScipyOptimizer(AbstractOptimizer):
     def run(self):
 
         # create init
-        x0 = self.parameters['value'].values
+        x0 = self.get_parameter('values')
 
         # create bounds
         if 'bounds' not in self.minimize_kwargs.keys():
             bounds = []
-            for i, row in self.parameters.iterrows():
-                lb, ub = row['lower_buond'], row['upper_bound']
+            for i, row in self.get_parameter('df').iterrows():
+                lb, ub = row['lower_bound'], row['upper_bound']
                 if lb is None: lb = -np.inf
                 if ub is None: ub = np.inf
                 bounds.append([lb, ub])

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

@@ -13,12 +13,16 @@ from scipy.optimize import minimize_scalar, OptimizeResult
 
 # pyfemtet relative
 from pyfemtet.opt._femopt_core import OptimizationStatus, generate_lhs
-from pyfemtet.opt.opt import AbstractOptimizer, logger, OptimizationMethodChecker
+from pyfemtet.opt.optimizer import AbstractOptimizer, logger, OptimizationMethodChecker
 from pyfemtet.core import MeshError, ModelError, SolveError
+from pyfemtet.message import Msg
 
 
 class ScipyScalarMethodChecker(OptimizationMethodChecker):
     def check_incomplete_bounds(self, raise_error=True): return True
+    def check_seed(self, raise_error=True):
+        logger.warning(Msg.WARN_SCIPY_DOESNT_NEED_SEED)
+        return True
 
 
 class ScipyScalarOptimizer(AbstractOptimizer):
@@ -41,8 +45,10 @@ class ScipyScalarOptimizer(AbstractOptimizer):
 
     def _objective(self, x: float):  # x: candidate parameter
         # update parameter
-        self.parameters['value'] = x
-        self.fem.update_parameter(self.parameters)
+
+        df = self.get_parameter('df')
+        df['value'] = x
+        self.fem.update_parameter(df)
 
         # strict constraints
         ...
@@ -72,19 +78,25 @@ class ScipyScalarOptimizer(AbstractOptimizer):
     def run(self):
 
         # create init
-        assert len(self.parameters) == 1
+        params = self.get_parameter()
+        assert len(params) == 1, print(f'{params} parameter(s) are passed.')
 
         # create bounds
         if 'bounds' not in self.minimize_kwargs.keys():
             bounds = []
-            for i, row in self.parameters.iterrows():
-                lb, ub = row['lower_bound'], row['upper_bound']
-                if lb is None: lb = -np.inf
-                if ub is None: ub = np.inf
-                bounds.append([lb, ub])
-            self.minimize_kwargs.update(
-                {'bounds': bounds}
-            )
+
+            row = self.get_parameter('df')
+            lb, ub = row['lower_bound'].iloc[0], row['upper_bound'].iloc[0]
+
+            if lb is None and ub is None:
+                pass
+            elif lb is None or ub is None:
+                raise ValueError('Both lower and upper bounds must be set.')
+            else:
+                bounds = [lb, ub]
+                self.minimize_kwargs.update(
+                    {'bounds': bounds}
+                )
 
         # run optimize
         try:

pyfemtet/opt/samples/femprj_sample/constrained_pipe.py

@@ -0,0 +1,97 @@
+"""A sample to implement constrained optimization.
+
+This section describes the types of constraints and
+the steps to run optimization on models that require them.
+
+"""
+
+from optuna_integration import BoTorchSampler
+from pyfemtet.opt import FEMOpt, OptunaOptimizer
+
+
+def mises_stress(Femtet):
+    """Calculate the von Mises stress as the objective function.
+
+    This function is called automatically by the FEMOpt
+    object while the optimization is running.
+
+    Args:
+        Femtet: When defining an objective or constraint
+            function using PyFemtet, the first argument
+            must take a Femtet instance.
+
+    Returns:
+        float: A single float representing the expression value you want to constrain.
+    """
+    return Femtet.Gogh.Galileo.GetMaxStress_py()[2]
+
+
+def radius_diff(Femtet, opt):
+    """Calculate the difference between the outer and inner radii of the pipe.
+
+    This constraint is called to ensure that the
+    inner radius of the pipe does not exceed the
+    outer radius while the optimization is running.
+
+    Note:
+        If you are using BoTorchSampler of OptunaOptimizer
+        and use strict constraints, be aware that accessing
+        the Femtet can be very slow, as it requires repeated
+        calculations to propose parameters.
+        We recommend that you do not access the Femtet,
+        but rather get the parameters and perform the
+        calculations via the Optimizer object, as in this
+        function example.
+
+        NOT recommended::
+
+            p = Femtet.GetVariableValue('p')
+
+        instead, use optimizer::
+
+            params = opt.get_parameter()
+            p = params['p']
+
+    Args:
+        Femtet: When defining an objective or constraint
+            function using PyFemtet, the first argument
+            must take a Femtet instance.
+        opt: This object allows you to obtain the outer
+            radius and inner radius values without going
+            through Femtet.
+    """
+    params = opt.get_parameter()
+    internal_r = params['internal_r']
+    external_r = params['external_r']
+    return external_r - internal_r
+
+
+if __name__ == '__main__':
+    # Setup optimization method
+    opt = OptunaOptimizer(
+        sampler_class=BoTorchSampler,
+        sampler_kwargs=dict(
+            n_startup_trials=3,  # The first three samples are randomly sampled.
+        )
+    )
+    femopt = FEMOpt(opt=opt)
+
+    # Add parameters
+    femopt.add_parameter("external_r", 10, lower_bound=0.1, upper_bound=10)
+    femopt.add_parameter("internal_r", 5, lower_bound=0.1, upper_bound=10)
+
+    # Add the strict constraint not to exceed the
+    # outer radius while the optimization is running.
+    femopt.add_constraint(
+        radius_diff,  # Constraint function (returns external radius - internal radius).
+        name='wall thickness',  # You can name the function anything you want.
+        lower_bound=1,  # Lower bound of constraint function (set minimum wall thickness is 1).
+        args=(femopt.opt,)  # Additional arguments passed to the function.
+    )
+
+    # Add the objective
+    femopt.add_objective(mises_stress, name='Mises Stress')
+
+    # Run optimization.
+    femopt.set_random_seed(42)
+    femopt.optimize(n_trials=10)

pyfemtet/opt/samples/femprj_sample/constrained_pipe_test_result.reccsv

@@ -0,0 +1,13 @@
+"",prm,prm_lb,prm_ub,prm,prm_lb,prm_ub,obj,obj_direction,,cns,cns_lb,cns_ub,,,,
+,,,,,,,,,,,,,,,,
+trial,external_r,external_r_lower_bound,external_r_upper_bound,internal_r,internal_r_lower_bound,internal_r_upper_bound,Mises Stress,Mises Stress_direction,non_domi,wall thickness,wall thickness_lower_bound,wall thickness_upper_bound,feasible,hypervolume,message,time
+1,10.0,0.1,10.0,5.0,0.1,10.0,2369132.9299968677,minimize,False,5.0,1,,True,-1.0,initial,2024-09-17 14:52:32.436730
+2,7.34674002393291,0.1,10.0,6.026718993550662,0.1,10.0,5797829.750527166,minimize,False,1.3200210303822484,1,,True,-1.0,,2024-09-17 14:52:42.927138
+3,8.341182143924176,0.1,10.0,2.202157195714934,0.1,10.0,1977631.590419345,minimize,False,6.139024948209242,1,,True,-1.0,,2024-09-17 14:52:54.382893
+4,9.999999999999995,0.1,10.0,0.6764719819158711,0.1,10.0,1514026.80705058,minimize,False,9.323528018084124,1,,True,-1.0,,2024-09-17 14:53:32.128331
+5,7.61174007452904,0.1,10.0,0.10000000000001566,0.1,10.0,398224.5447358758,minimize,True,7.511740074529024,1,,True,-1.0,,2024-09-17 14:54:08.541865
+6,5.026961232239628,0.1,10.0,0.10000000000001101,0.1,10.0,485322.32959281537,minimize,False,4.926961232239617,1,,True,-1.0,,2024-09-17 14:54:39.695340
+7,1.1000000916874046,0.1,10.0,0.1,0.1,10.0,613872.6231008903,minimize,False,1.0000000916874046,1,,True,-1.0,,2024-09-17 14:55:07.711879
+8,3.122874622702614,0.1,10.0,0.1,0.1,10.0,497544.0108231131,minimize,False,3.0228746227026138,1,,True,-1.0,,2024-09-17 14:55:41.036763
+9,9.999999999999998,0.1,10.0,3.7062659141309533,0.1,10.0,2092780.7380693094,minimize,False,6.293734085869045,1,,True,-1.0,,2024-09-17 14:56:28.269065
+10,6.601571760977393,0.1,10.0,0.10000000004171199,0.1,10.0,456263.04356135987,minimize,False,6.501571760935681,1,,True,-1.0,,2024-09-17 14:57:04.427906

pyfemtet/opt/{femprj_sample → samples/femprj_sample}/gal_ex58_parametric_test_result.reccsv

@@ -1,4 +1,4 @@
-"{""femprj_path"": ""E:\\pyfemtet\\pyfemtet\\pyfemtet\\opt\\femprj_sample\\gal_ex58_parametric.femprj"", ""model_name"": ""ex58_UnLoad""}",prm,prm_lb,prm_ub,obj,obj_direction,,,,,
+"",prm,prm_lb,prm_ub,obj,obj_direction,,,,,
 ,,,,,,,,,,
 trial,rot,rot_lower_bound,rot_upper_bound,final angle (degree),final angle (degree)_direction,non_domi,feasible,hypervolume,message,time
 1,90.0,80.0,100.0,81.62540666214329,90,False,True,-1.0,initial,2024-07-24 10:57:24.248429

pyfemtet/opt/{femprj_sample → samples/femprj_sample}/her_ex40_parametric.py

@@ -80,7 +80,7 @@ class SParameterCalculator:
         return self.resonance_frequency  # unit: Hz
         
 
-def antenna_is_smaller_than_substrate(Femtet):
+def antenna_is_smaller_than_substrate(Femtet, opt):
     """Calculate the relationship between antenna size and board size.
 
     This function is used to constrain the model
@@ -89,15 +89,17 @@ def antenna_is_smaller_than_substrate(Femtet):
     Returns:
         float: Difference between the substrate size and antenna size. Must be equal to or grater than 1 mm.
     """
-    r = Femtet.GetVariableValue('antenna_radius')
-    w = Femtet.GetVariableValue('substrate_w')
+    params = opt.get_parameter()
+    r = params['antenna_radius']
+    w = params['substrate_w']
     return w / 2 - r  # unit: mm
 
 
-def port_is_inside_antenna(Femtet):
+def port_is_inside_antenna(Femtet, opt):
     """Calculate the relationship between the feed port location and antenna size."""
-    r = Femtet.GetVariableValue('antenna_radius')
-    x = Femtet.GetVariableValue('port_x')
+    params = opt.get_parameter()
+    r = params['antenna_radius']
+    x = params['port_x']
     return r - x  # unit: mm. Must be equal to or grater than 1 mm.
 
 
@@ -125,8 +127,8 @@ if __name__ == '__main__':
     femopt.add_parameter('port_x', 5, 1, 20)
 
     # Add the constraint function to the optimization problem.
-    femopt.add_constraint(antenna_is_smaller_than_substrate, 'antenna and substrate clearance', lower_bound=1)
-    femopt.add_constraint(port_is_inside_antenna, 'antenna and port clearance', lower_bound=1)
+    femopt.add_constraint(antenna_is_smaller_than_substrate, 'antenna and substrate clearance', lower_bound=1, args=(opt,))
+    femopt.add_constraint(port_is_inside_antenna, 'antenna and port clearance', lower_bound=1, args=(opt,))
 
     # Add the objective function to the optimization problem.
     # The target frequency is 3.0 GHz.

pyfemtet/opt/samples/femprj_sample/her_ex40_parametric_test_result.reccsv

@@ -0,0 +1,18 @@
+"{""femprj_path"": ""E:\\pyfemtet\\pyfemtet\\pyfemtet\\opt\\femprj_sample\\her_ex40_parametric.femprj"", ""model_name"": ""Harm""}",prm,prm_lb,prm_ub,prm,prm_lb,prm_ub,prm,prm_lb,prm_ub,obj,obj_direction,,cns,cns_lb,cns_ub,cns,cns_lb,cns_ub,,,,
+,,,,,,,,,,,,,,,,,,,,,,
+trial,antenna_radius,antenna_radius_lower_bound,antenna_radius_upper_bound,substrate_w,substrate_w_lower_bound,substrate_w_upper_bound,port_x,port_x_lower_bound,port_x_upper_bound,first resonant frequency(Hz),first resonant frequency(Hz)_direction,non_domi,antenna and substrate clearance,antenna and substrate clearance_lower_bound,antenna and substrate clearance_upper_bound,antenna and port clearance,antenna and port clearance_lower_bound,antenna and port clearance_upper_bound,feasible,hypervolume,message,time
+1,10.0,5.0,20.0,50.0,40.0,60.0,5.0,1.0,20.0,4289000000.0,3000000000.0,False,15.0,1,,5.0,1,,True,-1.0,initial,2024-09-11 15:22:45.703728
+2,13.979877262955549,5.0,20.0,43.12037280884873,40.0,60.0,3.96389588638785,1.0,20.0,3050000000.0,3000000000.0,False,7.580309141468815,1,,10.015981376567698,1,,True,-1.0,,2024-09-11 15:23:00.502240
+3,17.48663961200633,5.0,20.0,44.246782213565524,40.0,60.0,4.4546743769349115,1.0,20.0,2460000000.0,3000000000.0,False,4.6367514947764334,1,,13.031965235071418,1,,True,-1.0,,2024-09-11 15:23:19.497216
+4,11.841049763255539,5.0,20.0,55.70351922786027,40.0,60.0,4.793801861008835,1.0,20.0,3581000000.0,3000000000.0,False,16.010709850674594,1,,7.047247902246704,1,,True,-1.0,,2024-09-11 15:23:38.392090
+5,12.713516576204174,5.0,20.0,51.84829137724085,40.0,60.0,1.8825578416799567,1.0,20.0,2932000000.0,3000000000.0,False,13.21062911241625,1,,10.830958734524218,1,,True,-1.0,,2024-09-11 15:23:50.146083
+6,14.113172778521575,5.0,20.0,43.41048247374583,40.0,60.0,2.235980266720311,1.0,20.0,2991000000.0,3000000000.0,True,7.59206845835134,1,,11.877192511801264,1,,True,-1.0,,2024-09-11 15:24:04.616007
+7,19.233283058799998,5.0,20.0,59.31264066149119,40.0,60.0,16.35954961421276,1.0,20.0,2283000000.0,3000000000.0,False,10.423037271945596,1,,2.873733444587238,1,,True,-1.0,,2024-09-11 15:24:33.762831
+8,11.60228740609402,5.0,20.0,42.44076469689558,40.0,60.0,10.408361292114133,1.0,20.0,3758000000.0,3000000000.0,False,9.61809494235377,1,,1.1939261139798862,1,,True,-1.0,,2024-09-11 15:24:53.700769
+9,14.93783426530973,5.0,20.0,46.23422152178822,40.0,60.0,10.881292402378406,1.0,20.0,2932000000.0,3000000000.0,False,8.17927649558438,1,,4.056541862931324,1,,True,-1.0,,2024-09-11 15:25:17.611571
+10,13.968499682166277,5.0,20.0,58.437484700462335,40.0,60.0,2.6813575389864703,1.0,20.0,2991000000.0,3000000000.0,True,15.25024266806489,1,,11.287142143179807,1,,True,-1.0,,2024-09-11 15:25:33.276468
+11,14.05789863217095,5.0,20.0,51.01059902831617,40.0,60.0,1.737571530783426,1.0,20.0,2991000000.0,3000000000.0,True,11.447400881987136,1,,12.320327101387523,1,,True,-1.0,,2024-09-11 15:26:05.718398
+12,14.201356537883626,5.0,20.0,52.843533197525375,40.0,60.0,7.413439727286647,1.0,20.0,3050000000.0,3000000000.0,False,12.220410060879061,1,,6.787916810596979,1,,True,-1.0,,2024-09-11 15:26:37.472938
+13,13.425463212064672,5.0,20.0,52.02680338112066,40.0,60.0,1.0,1.0,20.0,3109000000.0,3000000000.0,False,12.587938478495657,1,,12.425463212064672,1,,True,-1.0,,2024-09-11 15:27:05.737378
+14,14.859313853083268,5.0,20.0,48.76719051860414,40.0,60.0,4.518838210753849,1.0,20.0,2873000000.0,3000000000.0,False,9.524281406218801,1,,10.34047564232942,1,,True,-1.0,,2024-09-11 15:27:37.696689
+15,13.72477890084936,5.0,20.0,49.21346368364997,40.0,60.0,4.707562522313161,1.0,20.0,3050000000.0,3000000000.0,False,10.881952940975625,1,,9.0172163785362,1,,True,-1.0,,2024-09-11 15:28:09.261355