pyfemtet 1.0.8__tar.gz → 1.0.10__tar.gz

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyfemtet
-Version: 1.0.8
+Version: 1.0.10
 Summary: Design parameter optimization using Femtet.
 License: MIT
 Author: pyfemtet

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/femopt.py

@@ -1,4 +1,6 @@
 from __future__ import annotations
+
+import platform
 from typing import Callable, Sequence
 
 import os
@@ -114,8 +116,8 @@ class FEMOpt:
     def add_categorical_parameter(
             self,
             name: str,
-            initial_value: str | None = None,
-            choices: list[str] | None = None,
+            initial_value: SupportedVariableTypes | None = None,
+            choices: list[SupportedVariableTypes] | None = None,
             properties: dict[str, ...] | None = None,
             *,
             pass_to_fem: bool = True,
@@ -464,21 +466,22 @@ class FEMOpt:
                                'using the result viewer.\n'
                                'The result viewer can be launched by '
                                'performing one of the following actions:\n'
-                               '- (Windows only) Launch the `pyfemtet-opt-result-viewer` '
+                               '- {windows_only}Launch the `pyfemtet-opt-result-viewer` '
                                'shortcut on your desktop if exists.\n'
-                               '- (Windows only) Launch {path}.\n'
+                               '- {windows_only}Launch {path}.\n'
                                '- Execute "py -m pyfemtet.opt.visualization.history_viewer" '
                                'in the command line',
                     jp_message='プログラム終了後も、結果ビューワを使って最適化結果を'
                                '確認することができます。'
                                '結果ビューワは以下のいずれかを実施すると起動できます。\n'
-                               '- （Windows のみ）デスクトップの pyfemtet-opt-result-viewer '
+                               '- {windows_only}デスクトップの pyfemtet-opt-result-viewer '
                                'ショートカットを起動する\n'
-                               '- （Windows のみ）{dir} にある {filename} を起動する\n'
+                               '- {windows_only}{dir} にある {filename} を起動する\n'
                                '- コマンドラインで「py -m pyfemtet.opt.visualization.history_viewer」'
                                'を実行する',
                     dir=os.path.abspath(os.path.dirname(sys.executable)),
                     filename='pyfemtet-opt-result-viewer.exe (or .cmd)',
+                    windows_only='(Windows only) ' if platform.system() != 'Windows' else '',
                 )
                 print("====================")
                 print(confirm_msg)

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/history/_history.py

@@ -53,6 +53,11 @@ MAIN_FILTER: dict = {
 logger = get_module_logger('opt.history', False)
 
 
+class MetaColumnNames(StrEnum):
+    prm_num_value = 'prm.num.value'
+    prm_cat_value = 'prm.cat.value'
+
+
 def create_err_msg_from_exception(e: Exception):
     """:meta private:"""
     additional = ' '.join(map(str, e.args))
@@ -403,7 +408,7 @@ class ColumnManager:
                     if isinstance(param, NumericParameter):
                         # important
                         column_dtypes.update({prm_name: float})
-                        meta_columns.append('prm.num.value')
+                        meta_columns.append(MetaColumnNames.prm_num_value.value)
 
                         # later
                         f = CorrespondingColumnNameRuler.prm_lower_bound_name
@@ -421,7 +426,7 @@ class ColumnManager:
                     elif isinstance(param, CategoricalParameter):
                         # important
                         column_dtypes.update({prm_name: object})
-                        meta_columns.append('prm.cat.value')
+                        meta_columns.append(MetaColumnNames.prm_cat_value.value)
 
                         # later
                         f = CorrespondingColumnNameRuler.prm_choices_name
@@ -598,24 +603,26 @@ class ColumnManager:
         return self.filter_columns('other_output')
 
     @staticmethod
-    def _is_numerical_parameter(prm_name, columns):
-        prm_lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
-        return prm_lb_name in columns
+    def _is_numerical_parameter(prm_name, columns, meta_columns):
+        col_index = tuple(columns).index(prm_name)
+        meta_column = meta_columns[col_index]
+        return meta_column == MetaColumnNames.prm_num_value
 
     @staticmethod
-    def _is_categorical_parameter(prm_name, columns):
-        prm_choices_name = CorrespondingColumnNameRuler.prm_choices_name(prm_name)
-        return prm_choices_name in columns
+    def _is_categorical_parameter(prm_name, columns, meta_columns):
+        col_index = tuple(columns).index(prm_name)
+        meta_column = meta_columns[col_index]
+        return meta_column == MetaColumnNames.prm_cat_value
 
     def is_numerical_parameter(self, prm_name) -> bool:
-        return self._is_numerical_parameter(prm_name, tuple(self.column_dtypes.keys()))
+        return self._is_numerical_parameter(prm_name, tuple(self.column_dtypes.keys()), self.meta_columns)
 
     def is_categorical_parameter(self, prm_name) -> bool:
-        return self._is_categorical_parameter(prm_name, tuple(self.column_dtypes.keys()))
+        return self._is_categorical_parameter(prm_name, tuple(self.column_dtypes.keys()), self.meta_columns)
 
     @staticmethod
-    def _get_parameter(prm_name: str, df: pd.DataFrame) -> Parameter:
-        if ColumnManager._is_numerical_parameter(prm_name, df.columns):
+    def _get_parameter(prm_name: str, df: pd.DataFrame, meta_columns) -> Parameter:
+        if ColumnManager._is_numerical_parameter(prm_name, df.columns, meta_columns):
             out = NumericParameter()
             out.name = prm_name
             out.value = float(df[prm_name].dropna().values[-1])
@@ -641,7 +648,7 @@ class ColumnManager:
             else:
                 out.step = None
 
-        elif ColumnManager._is_categorical_parameter(prm_name, df.columns):
+        elif ColumnManager._is_categorical_parameter(prm_name, df.columns, meta_columns):
             out = CategoricalParameter()
             out.name = prm_name
             out.value = str(df[prm_name].dropna().values[-1])
@@ -1231,7 +1238,7 @@ class History:
 
             parameters: TrialInput = {}
             for prm_name in self.prm_names:
-                param = ColumnManager._get_parameter(prm_name, df)
+                param = ColumnManager._get_parameter(prm_name, df, meta_columns)
                 parameters.update({prm_name: param})
 
             self.finalize(
@@ -1462,11 +1469,22 @@ class History:
 
                 # float
                 if self._records.column_manager.is_numerical_parameter(prm_name):
+
                     lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
                     ub_name = CorrespondingColumnNameRuler.prm_upper_bound_name(prm_name)
+
+                    if np.isnan(row[lb_name]):
+                        low = df[prm_name].dropna().values.min()
+                    else:
+                        low = row[lb_name]
+
+                    if np.isnan(row[ub_name]):
+                        high = df[prm_name].dropna().values.max()
+                    else:
+                        high = row[ub_name]
+
                     dist = optuna.distributions.FloatDistribution(
-                        low=row[lb_name],
-                        high=row[ub_name],
+                        low=low, high=high
                     )
 
                 # categorical

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/interface/__init__.py

@@ -1,30 +1,36 @@
+from typing import TYPE_CHECKING
 import platform
 
 from ._base_interface import AbstractFEMInterface, NoFEM
 
-if platform.system() == 'Windows':
+# PyCharm 2025.1.2 では、以下のルールで参照先が決まる様子。仕様？
+# if 文の前後で...
+# - import されたクラスと定義されたクラスが混在する場合: 定義されたものが優先
+# - import されたクラス同士である場合: 条件の True / False に関わらず、 else 内のものを優先
+# - 定義されたクラス同士である場合: 条件の True / False に関わらず、 else 内のものを優先
+# なのでわざわざ _dummy_classes module を分割作成し、条件式を反転して
+# 実際の実装が参照されるようにした。
+# VSCode では TYPE_CHECKING が True となる節が優先される。
+if platform.system() != 'Windows' and not TYPE_CHECKING:
+    from _dummy_classes import (
+        FemtetInterface,
+        FemtetWithNXInterface,
+        FemtetWithSolidworksInterface,
+        ExcelInterface,
+    )
+
+else:
     from ._femtet_interface import FemtetInterface
     from ._femtet_with_nx_interface import FemtetWithNXInterface
     from ._femtet_with_solidworks import FemtetWithSolidworksInterface
     from ._excel_interface import ExcelInterface
     from ._with_excel_settings import *
     from ._with_excel_settings import __all__ as _with_excel_settings__all__
-else:
-    class DummyInterface:
-        def __init__(self, args, kwargs):
-            raise RuntimeError(f'{type(self).__name__} is only for Windows OS.')
-
-    class FemtetInterface(DummyInterface, AbstractFEMInterface): pass
-    class FemtetWithNXInterface(DummyInterface, AbstractFEMInterface): pass
-    class FemtetWithSolidworksInterface(DummyInterface, AbstractFEMInterface): pass
-    class ExcelInterface(DummyInterface, AbstractFEMInterface): pass
-
 
 from ._surrogate_model_interface import AbstractSurrogateModelInterfaceBase
 from ._surrogate_model_interface import BoTorchInterface
 from ._surrogate_model_interface import PoFBoTorchInterface
 
-
 __all__ = [
     'AbstractFEMInterface',
     'NoFEM',

pyfemtet-1.0.10/pyfemtet/opt/interface/_dummy_classes.py

@@ -0,0 +1,18 @@
+from pyfemtet.opt.interface._base_interface import AbstractFEMInterface
+
+
+class DummyInterface:
+    def __init__(self, *args, **kwargs):
+        raise RuntimeError(f'{type(self).__name__} is only for Windows OS.')
+
+
+class FemtetInterface(DummyInterface, AbstractFEMInterface): pass
+
+
+class FemtetWithNXInterface(DummyInterface, AbstractFEMInterface): pass
+
+
+class FemtetWithSolidworksInterface(DummyInterface, AbstractFEMInterface): pass
+
+
+class ExcelInterface(DummyInterface, AbstractFEMInterface): pass

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/interface/_femtet_interface/femtet_interface.py

@@ -224,8 +224,23 @@ class FemtetInterface(COMInterface):
         # femprj を開く
         self.open(self.femprj_path, self.model_name)
 
-    def close(self, timeout=15, force=True):  # 12 秒程度
+    def quit(self, timeout=15, force=True):
         """Force to terminate connected Femtet."""
+        logger.info(_('Closing Femtet (pid = {pid}) ...', pid=self.femtet_pid))
+        succeeded = _exit_or_force_terminate(
+            timeout=timeout, Femtet=self.Femtet, force=force)
+        if succeeded:
+            logger.info(_('Femtet is closed.'))
+        else:
+            logger.warning(_('Failed to close Femtet.'))
+
+    def close(self, timeout=15, force=True):  # 12 秒程度
+        """Destructor.
+
+        May not quit Femtet. If you want to quit certainly,
+        Please use `quit()` method.
+
+        """
 
         _set_autosave_enabled(self._original_autosave_enabled)
 
@@ -236,13 +251,7 @@ class FemtetInterface(COMInterface):
             return
 
         if self.quit_when_destruct:
-            logger.info(_('Closing Femtet (pid = {pid}) ...', pid=self.femtet_pid))
-            succeeded = _exit_or_force_terminate(
-                timeout=timeout, Femtet=self.Femtet, force=force)
-            if succeeded:
-                logger.info(_('Femtet is closed.'))
-            else:
-                logger.warning(_('Failed to close Femtet.'))
+            self.quit(timeout, force)
 
     def use_parametric_output_as_objective(
             self, number: int, direction: str | float = "minimize"
@@ -709,8 +718,21 @@ class FemtetInterface(COMInterface):
             if self.femtet_is_alive():
                 # 生きていてもここにきているなら
                 # 指定された Exception を送出する
-                logger.debug(" " * print_indent + error_message)
-                raise if_error(error_message)
+
+                try:
+                    last_err = self.Femtet.LastErrorMsg
+                except Exception:
+                    last_err = ''
+
+                logger.debug(
+                    " " * print_indent
+                    + error_message
+                    + f' / Femtet.LastErrorMsg: {last_err}'
+                )
+                raise if_error(
+                    error_message
+                    + f' / Femtet.LastErrorMsg: {last_err}'
+                )
 
             # 死んでいるなら再起動
             else:

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/interface/_surrogate_model_interface/base_surrogate_interface.py

@@ -61,6 +61,8 @@ class AbstractSurrogateModelInterfaceBase(AbstractFEMInterface):
                 # 新しく追加した model を使わない目的関数と見做して何もしない
                 if obj_name in self.train_history.obj_names:
                     obj.fun = lambda _, obj_name_=obj_name: self.current_obj_values[obj_name_]
+                    obj.args = tuple()
+                    obj.kwargs = dict()
 
         # dict で与えられた場合
         elif isinstance(self._output_directions, dict):

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/optimizer/_base_optimizer.py

@@ -228,8 +228,8 @@ class AbstractOptimizer:
     def add_categorical_parameter(
             self,
             name: str,
-            initial_value: str | None = None,
-            choices: list[str] | None = None,
+            initial_value: SupportedVariableTypes | None = None,
+            choices: list[SupportedVariableTypes] | None = None,
             properties: dict[str, ...] | None = None,
             *,
             pass_to_fem: bool = True,

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/optimizer/optuna_optimizer/_optuna_optimizer.py

@@ -117,8 +117,8 @@ class OptunaOptimizer(AbstractOptimizer):
     def add_categorical_parameter(
             self,
             name: str,
-            initial_value: str,
-            choices: list[str],
+            initial_value: SupportedVariableTypes,
+            choices: list[SupportedVariableTypes],
             properties: dict[str, ...] | None = None,
             *,
             pass_to_fem: bool = True,

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/prediction/_helper.py

@@ -22,7 +22,9 @@ __all__ = [
 ]
 
 
-def get_bounds_containing_entire_bounds(df: pd.DataFrame, prm_name) -> tuple[float, float]:
+def get_bounds_containing_entire_bounds(
+        df: pd.DataFrame, prm_name
+) -> tuple[float | None, float | None]:
     """Get param bounds with all bounds"""
 
     lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
@@ -31,7 +33,15 @@ def get_bounds_containing_entire_bounds(df: pd.DataFrame, prm_name) -> tuple[flo
     ub_name = CorrespondingColumnNameRuler.prm_upper_bound_name(prm_name)
     ub = df[ub_name].dropna().max()
 
-    return float(lb), float(ub)
+    lb = float(lb)
+    ub = float(ub)
+
+    if np.isnan(lb):
+        lb = None
+    if np.isnan(ub):
+        ub = None
+
+    return lb, ub
 
 
 def get_choices_containing_entire_bounds(df: pd.DataFrame, prm_name) -> set[CategoricalChoiceType]:
@@ -90,17 +100,31 @@ def get_params_list_from_ndarray(x: np.ndarray, history: History) -> list[dict[s
     return params_list
 
 
-def get_search_space(df: pd.DataFrame, history: History) -> dict[str, BaseDistribution]:
+def get_search_space(
+        df: pd.DataFrame, history: History
+) -> dict[str, BaseDistribution | None]:
     # get search_space
     search_space = dict()
     for prm_name in history.prm_names:
         if history._records.column_manager.is_numerical_parameter(prm_name):
             lb, ub = get_bounds_containing_entire_bounds(df, prm_name)
-            search_space.update({
-                prm_name: FloatDistribution(
-                    low=lb, high=ub,
-                )
-            })
+
+            if lb is None:
+                lb = df[prm_name].dropna().min()
+            if ub is None:
+                ub = df[prm_name].dropna().max()
+
+            if lb == ub:
+                # 固定値は search_space に含めない
+                pass
+
+            else:
+                search_space.update({
+                    prm_name: FloatDistribution(
+                        low=lb, high=ub,
+                    )
+                })
+
         elif history._records.column_manager.is_categorical_parameter(prm_name):
             choices: set = get_choices_containing_entire_bounds(df, prm_name)
             search_space.update({
@@ -145,6 +169,9 @@ def get_transformed_params(
 
     # calc transformed value
     for params in params_list:
+
+        # search_space に含まれない params の key は
+        # trans.transform() で無視される
         trans_prm_values: np.ndarray = trans.transform(params)
         out = np.concatenate(
             [out, [trans_prm_values]],

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/prediction/_model.py

@@ -102,6 +102,7 @@ class PyFemtetModel:
         self.current_trans = get_transform_0_1(df, history)
 
         # transform all values
+        # trans を作るときの search_space に含まれない prm_name はここで無視される
         transformed_x = get_transformed_params(df, history, self.current_trans)
 
         # bounds as setup maximum range

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/visualization/history_viewer/_complex_components/alert_region.py

@@ -21,13 +21,12 @@ class AlertRegion(AbstractPage):
     def setup_component(self):
         # alert
         # noinspection PyAttributeOutsideInit
-        self.alert_region = dbc.CardBody(children=[], id='alerts-card-body')
+        self.alert_region = dbc.CardBody(children=[])
 
         # clear alert
         # noinspection PyAttributeOutsideInit
         self.clear_alert_button = dbc.Button(
             children='Clear messages',
-            id='clear-messages-button',
             color='secondary',
             outline=True,
             className="position-relative",
@@ -50,8 +49,8 @@ class AlertRegion(AbstractPage):
 
         # ===== clear alerts ==-==
         @app.callback(
-            Output(self.alert_region.id, 'children', allow_duplicate=True),
-            Input(self.clear_alert_button.id, self.clear_alert_button.Prop.n_clicks),
+            Output(self.alert_region, 'children', allow_duplicate=True),
+            Input(self.clear_alert_button, self.clear_alert_button.Prop.n_clicks),
             prevent_initial_call=True,  # required if allow_duplicate=True
         )
         def clear_alerts(_):

{pyfemtet-1.0.8 → pyfemtet-1.0.10}/pyfemtet/opt/visualization/history_viewer/_complex_components/pm_graph.py

@@ -5,6 +5,7 @@ from dash.exceptions import PreventUpdate
 # components
 from pyfemtet.opt.visualization.history_viewer._wrapped_components import html
 from pyfemtet.opt.visualization.history_viewer._wrapped_components import dcc, dbc
+from pyfemtet.opt.visualization.history_viewer._complex_components.alert_region import *
 
 # graph
 import plotly.graph_objs as go
@@ -16,7 +17,8 @@ from pyfemtet.opt.prediction._model import *
 from pyfemtet.opt.prediction._helper import *
 from pyfemtet.opt.visualization.plotter.pm_graph_creator import plot2d, plot3d
 from pyfemtet.opt.visualization.history_viewer._base_application import AbstractPage, logger
-from pyfemtet._i18n import Msg
+from pyfemtet.opt.visualization.history_viewer._helper import has_full_bound
+from pyfemtet._i18n import Msg, _
 
 
 __all__ = [
@@ -142,11 +144,18 @@ class PredictionModelGraph(AbstractPage):
             value=[],
         )
 
+        # alert region subpage
+        self.alert_region: AlertRegion = AlertRegion()
+        self.add_subpage(self.alert_region)
+
     def setup_layout(self):
         self.card_header = dbc.CardHeader(self.tabs)
 
         self.card_body = dbc.CardBody(
-            children=html.Div([self.loading]),  # children=html.Div([self.loading, self.tooltip]),
+            children=html.Div([
+                self.loading,
+                self.alert_region.layout,
+            ]),  # children=html.Div([self.loading, self.tooltip]),
         )
 
         dropdown_rows = [
@@ -301,6 +310,7 @@ class PredictionModelGraph(AbstractPage):
         @app.callback(
             Output(self.graph, 'figure'),
             Output(self.command_manager, self.command_manager_prop),
+            Output(self.alert_region.alert_region, 'children', allow_duplicate=True),
             # To determine whether Process Monitor should update
             # the graph, the main graph remembers the current
             # amount of data.
@@ -340,18 +350,54 @@ class PredictionModelGraph(AbstractPage):
             # load history
             if self.application.history is None:
                 logger.error(Msg.ERR_NO_HISTORY_SELECTED)
-                return no_update, self.CommandState.ready.value  # to re-enable buttons, fire callback chain
+                # to re-enable buttons, fire callback chain
+                return (
+                    no_update,
+                    self.CommandState.ready.value,
+                    self.alert_region.create_alerts(Msg.ERR_NO_HISTORY_SELECTED),
+                )
             # prm_names = self.application.history.prm_names
 
             # check history
             if len(self.application.get_df()) == 0:
                 logger.error(Msg.ERR_NO_FEM_RESULT)
-                return no_update, self.CommandState.ready.value  # to re-enable buttons, fire callback chain
+                # to re-enable buttons, fire callback chain
+                return (
+                    no_update,
+                    self.CommandState.ready.value,
+                    self.alert_region.create_alerts(Msg.ERR_NO_FEM_RESULT, color='danger'),
+                )
 
             # check fit
             if not hasattr(self.pyfemtet_model, 'current_model'):
                 logger.error(Msg.ERR_NO_PREDICTION_MODEL)
-                return no_update, self.CommandState.ready.value  # to re-enable buttons, fire callback chain
+                # to re-enable buttons, fire callback chain
+                return (
+                    no_update,
+                    self.CommandState.ready.value,
+                    self.alert_region.create_alerts(Msg.ERR_NO_PREDICTION_MODEL, color='danger'),
+                )
+
+            # check fixed and no-boundary parameter,
+            # cancel to write graph.
+            if (
+                    not has_full_bound(self.application.history, axis1_label)
+                    or (is_3d and not has_full_bound(self.application.history, axis2_label))
+            ):
+                # to re-enable buttons, fire callback chain
+                return (
+                    go.Figure(),
+                    self.CommandState.ready.value,
+                    self.alert_region.create_alerts(
+                        _(
+                            en_message='Cannot draw the graph because the selected parameter '
+                                       'is a fixed and its bounds are not given.',
+                            jp_message='選択された変数は固定値で上下限も与えられていないため、'
+                                       'グラフを描画できません。',
+                        ),
+                        color='danger',
+                    ),
+                )
 
             # create params
             params = dict()
@@ -394,7 +440,7 @@ class PredictionModelGraph(AbstractPage):
                     n=200,
                 )
 
-            return fig, self.CommandState.ready.value
+            return fig, self.CommandState.ready.value, []
 
         # ===== re-enable buttons when the graph is updated,  =====
         @app.callback(
@@ -442,20 +488,25 @@ class PredictionModelGraph(AbstractPage):
                 logger.error(Msg.ERR_NO_HISTORY_SELECTED)
                 raise PreventUpdate
 
-            # add dropdown item to dropdown
+            # add dropdown item to dropdown 1, 2 (input)
             axis1_dropdown_items, axis2_dropdown_items = [], []
             for i, prm_name in enumerate(self.application.history.prm_names):
+
+                # dropdown1 (x)
                 dm_item_1 = dbc.DropdownMenuItem(
                     children=prm_name,
                     id={'type': 'axis1-dropdown-menu-item', 'index': prm_name},
                 )
                 axis1_dropdown_items.append(dm_item_1)
 
+                # dropdown2 (y)
                 dm_item_2 = dbc.DropdownMenuItem(
                     children=prm_name,
                     id={'type': 'axis2-dropdown-menu-item', 'index': prm_name},
                 )
                 axis2_dropdown_items.append(dm_item_2)
+
+            # add dropdown item to dropdown 3 (output)
             axis3_dropdown_items = []
             for i, obj_name in enumerate(self.application.history.obj_names):
                 dm_item = dbc.DropdownMenuItem(
@@ -464,6 +515,8 @@ class PredictionModelGraph(AbstractPage):
                 )
                 axis3_dropdown_items.append(dm_item)
 
+            df = self.application.get_df()
+
             # add sliders
             sliders = []
             slider_values = {}
@@ -475,6 +528,11 @@ class PredictionModelGraph(AbstractPage):
                         prm_name,
                     )
 
+                    if lb is None:
+                        lb = df[prm_name].dropna().min()
+                    if ub is None:
+                        ub = df[prm_name].dropna().max()
+
                     # create slider
                     value = (lb + ub) / 2
                     slider = dcc.Slider(
@@ -580,8 +638,23 @@ class PredictionModelGraph(AbstractPage):
 
             # by callback chain on loaded after setup_dropdown_and_sliders()
             if callback_context.triggered_id == self.axis1_prm_dropdown.id:
-                ret[ax1_label_key] = prm_names[0]
-                ret[ax2_label_key] = prm_names[1] if len(prm_names) >= 2 else ''
+
+                # avoid unable choice
+                index = None
+                for i in range(len(prm_names)):
+                    if has_full_bound(self.application.history, prm_names[i]):
+                        ret[ax1_label_key] = prm_names[i]
+                        index = i
+                        break
+
+                ret[ax2_label_key] = ''
+                if index is not None:
+                    for j in range(index + 1, len(prm_names)):
+                        # ret[ax2_label_key] = prm_names[1] if len(prm_names) >= 2 else ''
+                        if has_full_bound(self.application.history, prm_names[j]):
+                            ret[ax2_label_key] = prm_names[j]
+                            break
+
                 ret[ax3_label_key] = obj_names[0]
 
             # by dropdown clicked

pyfemtet-1.0.10/pyfemtet/opt/visualization/history_viewer/_helper.py

@@ -0,0 +1,28 @@
+import numpy as np
+import pandas as pd
+from pyfemtet.opt.history import *
+
+
+def has_full_bound(history: History, prm_name, df: pd.DataFrame = None) -> bool:
+    if df is None:
+        df = history.get_df()
+
+    lb_name = CorrespondingColumnNameRuler.prm_lower_bound_name(prm_name)
+    if lb_name in df.columns:
+        lb = df[lb_name].dropna().min()
+    else:
+        lb = df[prm_name].dropna().min()
+
+    ub_name = CorrespondingColumnNameRuler.prm_upper_bound_name(prm_name)
+    if ub_name in df.columns:
+        ub = df[ub_name].dropna().max()
+    else:
+        ub = df[prm_name].dropna().max()
+
+    if lb == ub:
+        return False
+
+    if np.isnan(float(lb)) or np.isnan(float(ub)):
+        return False
+
+    return True