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

pyfemtet/opt/optimizer/_optuna_botorchsampler_parameter_constraint_helper.py

@@ -0,0 +1,331 @@
+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 =====
+    trial: Trial
+    for trial in study.trials[-1::-1]:
+        if len(trial.distributions) > 0:
+            break
+    else:
+        raise RuntimeError('Cannot detect bounds because of no COMPLETE trials. Certify 1 or more sampling excluding initial conditions.')
+    search_space = study.sampler.infer_relative_search_space(study, trial)
+    trans = _SearchSpaceTransform(trial.distributions, 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/{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

pyfemtet/opt/{femprj_sample_jp → samples/femprj_sample_jp}/her_ex40_parametric_jp.py

@@ -80,7 +80,7 @@ class SParameterCalculator:
         return self.resonance_frequency  # 単位: Hz
         
 
-def antenna_is_smaller_than_substrate(Femtet):
+def antenna_is_smaller_than_substrate(Femtet, opt):
     """アンテナの大きさと基板の大きさの関係を計算します。
 
     この関数は、変数の更新によってモデル形状が破綻しないように
@@ -92,15 +92,17 @@ def antenna_is_smaller_than_substrate(Femtet):
     Returns:
         float: 基板エッジとアンテナエッジの間隙。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  # 単位: mm
 
 
-def port_is_inside_antenna(Femtet):
+def port_is_inside_antenna(Femtet, opt):
     """給電ポートの位置とアンテナの大きさの関係を計算します。"""
-    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  # 単位: mm。1 mm 以上が必要です。
 
 
@@ -125,8 +127,8 @@ if __name__ == '__main__':
     femopt.add_parameter('port_x', 5, 1, 20)
 
     # 拘束関数を最適化問題に追加
-    femopt.add_constraint(antenna_is_smaller_than_substrate, 'アンテナと基板エッジの間隙', lower_bound=1)
-    femopt.add_constraint(port_is_inside_antenna, 'アンテナエッジと給電ポートの間隙', lower_bound=1)
+    femopt.add_constraint(antenna_is_smaller_than_substrate, 'アンテナと基板エッジの間隙', lower_bound=1, args=(opt,))
+    femopt.add_constraint(port_is_inside_antenna, 'アンテナエッジと給電ポートの間隙', lower_bound=1, args=(opt,))
 
     # 目的関数を最適化問題に追加
     # 共振周波数の目標は 3.0 GHz です。

pyfemtet/opt/visualization/complex_components/main_figure_creator.py

@@ -1,3 +1,4 @@
+import pandas as pd
 import plotly.graph_objs as go
 import plotly.express as px
 
@@ -200,3 +201,71 @@ def _get_multi_objective_pairplot(history, df):
     )
 
     return fig
+
+
+def get_objective_plot(history: History, df: pd.DataFrame, obj_names: list[str]) -> go.Figure:
+    df = _ls.localize(df)
+    df.columns = [c.replace(' / ', '<BR>/ ') for c in df.columns]
+    obj_names = [o.replace(' / ', '<BR>/ ') for o in obj_names]
+
+    common_kwargs = dict(
+        color=_ls.non_domi['label'],
+        color_discrete_map={
+            _ls.non_domi[True]: _cs.non_domi[True],
+            _ls.non_domi[False]: _cs.non_domi[False],
+        },
+        symbol=_ls.feasible['label'],
+        symbol_map={
+            _ls.feasible[True]: _ss.feasible[True],
+            _ls.feasible[False]: _ss.feasible[False],
+        },
+        custom_data=['trial'],
+        category_orders={
+            _ls.feasible['label']: (_ls.feasible[False], _ls.feasible[True]),
+            _ls.non_domi['label']: (_ls.non_domi[False], _ls.non_domi[True]),
+        },
+    )
+
+    if len(obj_names) == 2:
+        fig = px.scatter(
+            data_frame=df,
+            x=obj_names[0],
+            y=obj_names[1],
+            **common_kwargs,
+        )
+        fig.update_layout(
+            dict(
+                xaxis_title=obj_names[0],
+                yaxis_title=obj_names[1],
+            )
+        )
+
+    elif len(obj_names) == 3:
+        fig = px.scatter_3d(
+            df,
+            x=obj_names[0],
+            y=obj_names[1],
+            z=obj_names[2],
+            **common_kwargs,
+        )
+        fig.update_layout(
+            margin=dict(l=0, r=0, b=0, t=30),
+        )
+        fig.update_traces(
+            marker=dict(
+                size=3,
+            ),
+        )
+
+    else:
+        raise Exception
+
+    fig.update_layout(
+        dict(
+            title_text="Objective plot",
+        )
+    )
+
+    fig.update_traces(hoverinfo="none", hovertemplate=None)
+
+    return fig