pyfemtet 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyfemtet/opt/interface/_excel_interface.py

@@ -2,6 +2,7 @@ import os
 from pathlib import Path
 from time import sleep
 import gc
+from typing import Optional, List
 
 import pandas as pd
 import numpy as np
@@ -18,7 +19,7 @@ from pywintypes import com_error
 
 from pyfemtet.opt import FEMInterface
 from pyfemtet.core import SolveError
-from pyfemtet.opt.optimizer.parameter import Parameter
+from pyfemtet.opt.optimizer.parameter import Parameter, Expression
 
 from pyfemtet.dispatch_extensions import _get_pid, dispatch_specific_femtet
 
@@ -26,8 +27,10 @@ from pyfemtet._femtet_config_util.exit import _exit_or_force_terminate
 
 from pyfemtet._util.excel_macro_util import watch_excel_macro_error
 from pyfemtet._util.dask_util import lock_or_no_lock
+from pyfemtet._util.excel_parse_util import *
 
 from pyfemtet._warning import show_experimental_warning
+from pyfemtet._message.messages import Message as Msg
 
 from pyfemtet.opt.interface._base import logger
 
@@ -178,6 +181,8 @@ class ExcelInterface(FEMInterface):
     input_sheet_name: str  # 変数セルを定義しているシート名
     output_xlsm_path: str  # 操作対象の xlsm パス (指定しない場合、input と同一)
     output_sheet_name: str  # 計算結果セルを定義しているシート名 (指定しない場合、input と同一)
+    constraint_xlsm_path: str  # 操作対象の xlsm パス (指定しない場合、input と同一)
+    constraint_sheet_name: str  # 拘束関数セルを定義しているシート名 (指定しない場合、input と同一)
 
     related_file_paths: list[str]  # 並列時に個別に並列プロセスの space にアップロードする必要のあるパス
 
@@ -189,6 +194,8 @@ class ExcelInterface(FEMInterface):
     sh_input: CDispatch  # 変数の定義された WorkSheet
     wb_output: CDispatch  # システムを構成する Workbook
     sh_output: CDispatch  # 計算結果の定義された WorkSheet (sh_input と同じでもよい)
+    wb_constraint: CDispatch  # システムを構成する Workbook
+    sh_constraint: CDispatch  # 計算結果の定義された WorkSheet (sh_input と同じでもよい)
     wb_setup: CDispatch  # システムを構成する Workbook
     wb_teardown: CDispatch  # システムを構成する Workbook
 
@@ -210,12 +217,16 @@ class ExcelInterface(FEMInterface):
     teardown_procedure_name: str
     teardown_procedure_args: list or tuple
 
+    use_named_range: bool  # input を定義したシートにおいて input の値を名前付き範囲で指定するかどうか。
+
     def __init__(
             self,
             input_xlsm_path: str or Path,
             input_sheet_name: str,
             output_xlsm_path: str or Path = None,
             output_sheet_name: str = None,
+            constraint_xlsm_path: str or Path = None,
+            constraint_sheet_name: str = None,
             procedure_name: str = None,
             procedure_args: list or tuple = None,
             connect_method: str = 'auto',  # or 'new'
@@ -231,6 +242,7 @@ class ExcelInterface(FEMInterface):
             display_alerts: bool = False,
             terminate_excel_when_quit: bool = None,
             interactive: bool = True,
+            use_named_range: bool = True,
     ):
 
         show_experimental_warning("ExcelInterface")
@@ -239,7 +251,9 @@ class ExcelInterface(FEMInterface):
         self.input_xlsm_path = str(input_xlsm_path)  # あとで再取得する
         self.input_sheet_name = input_sheet_name
         self.output_xlsm_path = str(input_xlsm_path) if output_xlsm_path is None else str(output_xlsm_path)
-        self.output_sheet_name = output_sheet_name or self.input_sheet_name
+        self.output_sheet_name = output_sheet_name if output_sheet_name is not None else input_sheet_name
+        self.constraint_xlsm_path = str(input_xlsm_path) if constraint_xlsm_path is None else str(constraint_xlsm_path)
+        self.constraint_sheet_name = constraint_sheet_name or self.input_sheet_name
         self.procedure_name = procedure_name or 'FemtetMacro.FemtetMain'
         self.procedure_args = procedure_args or []
         assert connect_method in ['new', 'auto']
@@ -264,12 +278,15 @@ class ExcelInterface(FEMInterface):
         self.interactive = interactive
         self.display_alerts = display_alerts
 
+        self.use_named_range = use_named_range
+
         # dask サブプロセスのときは space 直下の input_xlsm_path を参照する
         try:
             worker = get_worker()
             space = os.path.abspath(worker.local_directory)
             self.input_xlsm_path = os.path.join(space, os.path.basename(self.input_xlsm_path))
             self.output_xlsm_path = os.path.join(space, os.path.basename(self.output_xlsm_path))
+            self.constraint_xlsm_path = os.path.join(space, os.path.basename(self.constraint_xlsm_path))
             self.setup_xlsm_path = os.path.join(space, os.path.basename(self.setup_xlsm_path))
             self.teardown_xlsm_path = os.path.join(space, os.path.basename(self.teardown_xlsm_path))
             self.related_file_paths = [os.path.join(space, os.path.basename(p)) for p in self.related_file_paths]
@@ -278,6 +295,7 @@ class ExcelInterface(FEMInterface):
         except ValueError:
             self.input_xlsm_path = os.path.abspath(self.input_xlsm_path)
             self.output_xlsm_path = os.path.abspath(self.output_xlsm_path)
+            self.constraint_xlsm_path = os.path.abspath(self.constraint_xlsm_path)
             self.setup_xlsm_path = os.path.abspath(self.setup_xlsm_path)
             self.teardown_xlsm_path = os.path.abspath(self.teardown_xlsm_path)
             self.related_file_paths = [os.path.abspath(p) for p in self.related_file_paths]
@@ -288,6 +306,8 @@ class ExcelInterface(FEMInterface):
             input_sheet_name=self.input_sheet_name,
             output_xlsm_path=self.output_xlsm_path,
             output_sheet_name=self.output_sheet_name,
+            constraint_xlsm_path=self.constraint_xlsm_path,
+            constraint_sheet_name=self.constraint_sheet_name,
             procedure_name=self.procedure_name,
             procedure_args=self.procedure_args,
             connect_method='new',  # subprocess で connect する際は new を強制する
@@ -303,6 +323,7 @@ class ExcelInterface(FEMInterface):
             visible=self.visible,
             interactive=self.interactive,
             display_alerts=self.display_alerts,
+            use_named_range=self.use_named_range,
         )
         FEMInterface.__init__(self, **kwargs)
 
@@ -317,6 +338,9 @@ class ExcelInterface(FEMInterface):
         if not is_same_path(self.input_xlsm_path, self.output_xlsm_path):
             client.upload_file(self.output_xlsm_path, False)
 
+        if not is_same_path(self.input_xlsm_path, self.constraint_xlsm_path):
+            client.upload_file(self.constraint_xlsm_path, False)
+
         if not is_same_path(self.input_xlsm_path, self.setup_xlsm_path):
             client.upload_file(self.setup_xlsm_path, False)
 
@@ -336,6 +360,7 @@ class ExcelInterface(FEMInterface):
             if space is not None:
                 self.input_xlsm_path = os.path.join(space, os.path.basename(self.input_xlsm_path))
                 self.output_xlsm_path = os.path.join(space, os.path.basename(self.output_xlsm_path))
+                self.constraint_xlsm_path = os.path.join(space, os.path.basename(self.constraint_xlsm_path))
                 self.setup_xlsm_path = os.path.join(space, os.path.basename(self.setup_xlsm_path))
                 self.teardown_xlsm_path = os.path.join(space, os.path.basename(self.teardown_xlsm_path))
                 self.related_file_paths = [os.path.join(space, os.path.basename(p)) for p in self.related_file_paths]
@@ -354,6 +379,7 @@ class ExcelInterface(FEMInterface):
 
         self.input_xlsm_path = proc_path(self.input_xlsm_path, False)
         self.output_xlsm_path = proc_path(self.output_xlsm_path, True)
+        self.constraint_xlsm_path = proc_path(self.constraint_xlsm_path, True)
         self.setup_xlsm_path = proc_path(self.setup_xlsm_path, True)
         self.teardown_xlsm_path = proc_path(self.teardown_xlsm_path, True)
 
@@ -367,18 +393,25 @@ class ExcelInterface(FEMInterface):
             _set_autosave_enabled(False)
 
         # excel に繋ぐ
-        self.connect_excel(self.connect_method)
+        with lock_or_no_lock('connect-excel'):
+            self.connect_excel(self.connect_method)
+            sleep(1)
 
         # load_objective は 1 回目に呼ばれたのが main thread なので
         # subprocess に入った後でもう一度 load objective を行う
         from pyfemtet.opt.optimizer import AbstractOptimizer
-        from pyfemtet.opt._femopt_core import Objective
+        from pyfemtet.opt._femopt_core import Objective, Constraint
         opt: AbstractOptimizer = kwargs['opt']
         obj: Objective
         for obj_name, obj in opt.objectives.items():
             if isinstance(obj.fun, ScapeGoatObjective):
                 opt.objectives[obj_name].fun = self.objective_from_excel
 
+        cns: Constraint
+        for cns_name, cns in opt.constraints.items():
+            if isinstance(cns.fun, ScapeGoatObjective):
+                opt.constraints[cns_name].fun = self.constraint_from_excel
+
         # excel の setup 関数を必要なら実行する
         if self.setup_procedure_name is not None:
             with lock_or_no_lock('excel_setup_procedure'):
@@ -391,9 +424,10 @@ class ExcelInterface(FEMInterface):
 
                     # 再計算
                     self.excel.CalculateFull()
+                    sleep(1)
 
                 except com_error as e:
-                    raise RuntimeError(f'Failed to run macro {self.setup_procedure_args}. The original message is: {e}')
+                    raise RuntimeError(f'Failed to run macro {self.setup_procedure_name}. The original message is: {e}')
 
     def connect_excel(self, connect_method):
 
@@ -404,6 +438,10 @@ class ExcelInterface(FEMInterface):
         else:
             self.excel = DispatchEx('Excel.Application')
 
+        # FemtetRef を追加する
+        self.open_femtet_ref_xla()  # ここでエラーが発生しているかも？
+        sleep(0.5)
+
         # 起動した excel の pid を記憶する
         self._excel_hwnd = self.excel.hWnd
         self._excel_pid = 0
@@ -415,7 +453,9 @@ class ExcelInterface(FEMInterface):
         self.excel.Visible = self.visible
         self.excel.DisplayAlerts = self.display_alerts
         self.excel.Interactive = self.interactive
+        sleep(0.5)
 
+        # ===== input =====
         # 開く
         self.excel.Workbooks.Open(str(self.input_xlsm_path))
         for wb in self.excel.Workbooks:
@@ -433,6 +473,7 @@ class ExcelInterface(FEMInterface):
         else:
             raise RuntimeError(f'Sheet {self.input_sheet_name} does not exist in the book {self.wb_input.Name}.')
 
+        # ===== output =====
         # 開く (output)
         if is_same_path(self.input_xlsm_path, self.output_xlsm_path):
             self.wb_output = self.wb_input
@@ -453,6 +494,28 @@ class ExcelInterface(FEMInterface):
         else:
             raise RuntimeError(f'Sheet {self.output_sheet_name} does not exist in the book {self.wb_output.Name}.')
 
+        # ===== constraint =====
+        # 開く (constraint)
+        if is_same_path(self.input_xlsm_path, self.constraint_xlsm_path):
+            self.wb_constraint = self.wb_input
+        else:
+            self.excel.Workbooks.Open(str(self.constraint_xlsm_path))
+            for wb in self.excel.Workbooks:
+                if wb.Name == os.path.basename(self.constraint_xlsm_path):
+                    self.wb_constraint = wb
+                    break
+            else:
+                raise RuntimeError(f'Cannot open {self.constraint_xlsm_path}')
+
+        # シートを特定する (constraint)
+        for sh in self.wb_constraint.WorkSheets:
+            if sh.Name == self.constraint_sheet_name:
+                self.sh_constraint = sh
+                break
+        else:
+            raise RuntimeError(f'Sheet {self.constraint_sheet_name} does not exist in the book {self.wb_constraint.Name}.')
+
+        # ===== setup =====
         # 開く (setup)
         if is_same_path(self.input_xlsm_path, self.setup_xlsm_path):
             self.wb_setup = self.wb_input
@@ -465,6 +528,7 @@ class ExcelInterface(FEMInterface):
             else:
                 raise RuntimeError(f'Cannot open {self.setup_xlsm_path}')
 
+        # ===== teardown =====
         # 開く (teardown)
         if is_same_path(self.input_xlsm_path, self.teardown_xlsm_path):
             self.wb_teardown = self.wb_input
@@ -478,28 +542,29 @@ class ExcelInterface(FEMInterface):
                 raise RuntimeError(f'Cannot open {self.teardown_xlsm_path}')
 
         # book に参照設定を追加する
-        self.add_femtet_ref_xla(self.wb_input)
-        self.add_femtet_ref_xla(self.wb_output)
-        self.add_femtet_ref_xla(self.wb_setup)
-        self.add_femtet_ref_xla(self.wb_teardown)
+        self.add_femtet_macro_reference(self.wb_input)
+        self.add_femtet_macro_reference(self.wb_output)
+        self.add_femtet_macro_reference(self.wb_setup)
+        self.add_femtet_macro_reference(self.wb_teardown)
+        self.add_femtet_macro_reference(self.wb_constraint)
 
-    def add_femtet_ref_xla(self, wb):
+    def open_femtet_ref_xla(self):
 
-        # search
-        ref_file_1 = r'C:\Program Files\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
-        if not os.path.exists(ref_file_1):
-            # 32bit
-            ref_file_1 = r'C:\Program Files (x86)\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
-        if not os.path.exists(ref_file_1):
-            raise FileNotFoundError(f'{ref_file_1} not found. Please check the "Enable Macros" command was fired.')
-        contain_1 = False
-        for ref in wb.VBProject.References:
-            if ref.FullPath is not None:
-                if ref.FullPath.lower() == ref_file_1.lower():
-                    contain_1 = True
-        # add
-        if not contain_1:
-            wb.VBProject.References.AddFromFile(ref_file_1)
+        # get 64 bit
+        xla_file_path = r'C:\Program Files\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
+
+        # if not exist, get 32bit
+        if not os.path.exists(xla_file_path):
+            xla_file_path = r'C:\Program Files (x86)\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
+
+        # certify
+        if not os.path.exists(xla_file_path):
+            raise FileNotFoundError(f'{xla_file_path} not found. Please check the "Enable Macros" command was fired.')
+
+        # self.excel.Workbooks.Add(xla_file_path)
+        self.excel.Workbooks.Open(xla_file_path, ReadOnly=True)
+
+    def add_femtet_macro_reference(self, wb):
 
         # search
         ref_file_2 = os.path.abspath(util._get_femtetmacro_dllpath())
@@ -508,44 +573,47 @@ class ExcelInterface(FEMInterface):
             if ref.Description is not None:
                 if ref.Description == 'FemtetMacro':  # FemtetMacro
                     contain_2 = True
+                    break
         # add
         if not contain_2:
             wb.VBProject.References.AddFromFile(ref_file_2)
 
     def remove_femtet_ref_xla(self, wb):
-
-        # search
-        ref_file_1 = r'C:\Program Files\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
-        if not os.path.exists(ref_file_1):
-            # 32bit
-            ref_file_1 = r'C:\Program Files (x86)\Microsoft Office\root\Office16\XLSTART\FemtetRef.xla'
-        if not os.path.exists(ref_file_1):
-            raise FileNotFoundError(f'{ref_file_1} not found. Please check the "Enable Macros" command was fired.')
-        for ref in wb.VBProject.References:
-            if ref.FullPath is not None:
-                if ref.FullPath == ref_file_1:  # or ``FemtetMacroを使用するための参照設定を自動で行ないます。``
-                    wb.VBProject.References.Remove(ref)
-
         # search
         for ref in wb.VBProject.References:
             if ref.Description is not None:
                 if ref.Description == 'FemtetMacro':  # FemtetMacro
                     wb.VBProject.References.Remove(ref)
 
-    def update(self, parameters: pd.DataFrame) -> None:
-
+    def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
         # params を作成
         params = dict()
         for _, row in parameters.iterrows():
             params[row['name']] = row['value']
 
         # excel シートの変数更新
-        for key, value in params.items():
-            self.sh_input.Range(key).value = value
+        if self.use_named_range:
+            for key, value in params.items():
+                try:
+                    self.sh_input.Range(key).value = value
+                except com_error:
+                    logger.warn('The cell address specification by named range is failed. '
+                                'The process changes the specification way to table based method.')
+                    self.use_named_range = False
+                    break
+
+        if not self.use_named_range:  # else にしないこと
+            for name, value in params.items():
+                r = 1 + search_r(self.input_xlsm_path, self.input_sheet_name, name)
+                c = 1 + search_c(self.input_xlsm_path, self.input_sheet_name, ParseAsParameter.value)
+                self.sh_input.Cells(r, c).value = value
 
         # 再計算
         self.excel.CalculateFull()
 
+    def update(self, parameters: pd.DataFrame) -> None:
+        self.update_parameter(parameters)
+
         # マクロ実行
         try:
             with watch_excel_macro_error(self.excel, timeout=self.procedure_timeout):
@@ -567,12 +635,12 @@ class ExcelInterface(FEMInterface):
             if already_terminated:
                 return
 
-            logger.info('Excel の終了処理を開始します。')
+            logger.info(Msg.INFO_TERMINATING_EXCEL)
 
             # 参照設定解除の前に終了処理を必要なら実施する
             # excel の setup 関数を必要なら実行する
             if self.teardown_procedure_name is not None:
-                with lock_or_no_lock('excel_setup_procedure'):
+                with lock_or_no_lock('excel_teardown_procedure'):
                     try:
                         with watch_excel_macro_error(self.excel, timeout=self.procedure_timeout, restore_book=False):
                             self.excel.Run(
@@ -586,15 +654,17 @@ class ExcelInterface(FEMInterface):
                     except com_error as e:
                         raise RuntimeError(f'Failed to run macro {self.teardown_procedure_args}. The original message is: {e}')
 
-            # 参照設定を解除する（不要な処理かも）
-            self.remove_femtet_ref_xla(self.wb_input)
-            self.remove_femtet_ref_xla(self.wb_output)
-            self.remove_femtet_ref_xla(self.wb_setup)
-            self.remove_femtet_ref_xla(self.wb_teardown)
+            # 不具合の原因になる場合があるので参照設定は解除しないこと
+            # self.remove_femtet_ref_xla(self.wb_input)
+            # self.remove_femtet_ref_xla(self.wb_output)
+            # self.remove_femtet_ref_xla(self.wb_constraint)
+            # self.remove_femtet_ref_xla(self.wb_setup)
+            # self.remove_femtet_ref_xla(self.wb_teardown)
 
             # シートの COM オブジェクト変数を削除する
             del self.sh_input
             del self.sh_output
+            del self.sh_constraint
 
             # workbook を閉じる
             with watch_excel_macro_error(self.excel, timeout=10, restore_book=False):
@@ -604,6 +674,10 @@ class ExcelInterface(FEMInterface):
                 with watch_excel_macro_error(self.excel, timeout=10, restore_book=False):
                     self.wb_output.Close(SaveChanges := False)
 
+            if not is_same_path(self.input_xlsm_path, self.constraint_xlsm_path):
+                with watch_excel_macro_error(self.excel, timeout=10, restore_book=False):
+                    self.wb_constraint.Close(SaveChanges := False)
+
             if not is_same_path(self.input_xlsm_path, self.setup_xlsm_path):
                 with watch_excel_macro_error(self.excel, timeout=10, restore_book=False):
                     self.wb_setup.Close(SaveChanges := False)
@@ -614,10 +688,10 @@ class ExcelInterface(FEMInterface):
 
             del self.wb_input
             del self.wb_output
+            del self.wb_constraint
             del self.wb_setup
             del self.wb_teardown
 
-
             # excel の終了
             with watch_excel_macro_error(self.excel, timeout=10, restore_book=False):
                 self.excel.Quit()
@@ -625,12 +699,12 @@ class ExcelInterface(FEMInterface):
 
             # ここで Excel のプロセスが残らず落ちる
             gc.collect()
+            logger.info(Msg.INFO_TERMINATED_EXCEL)
 
             if self._with_femtet_autosave_setting:
                 from pyfemtet._femtet_config_util.autosave import _set_autosave_enabled
-                logger.info('自動保存機能の設定を元に戻しています。')
+                logger.info(Msg.INFO_RESTORING_FEMTET_AUTOSAVE)
                 _set_autosave_enabled(self._femtet_autosave_buffer)
-                logger.info('自動保存機能の設定を元に戻しました。')
 
     # 直接アクセスしてもよいが、ユーザーに易しい名前にするためだけのプロパティ
     @property
@@ -653,93 +727,180 @@ class ExcelInterface(FEMInterface):
         from pyfemtet.opt.optimizer import AbstractOptimizer, logger
         opt: AbstractOptimizer
 
-        df = pd.read_excel(
-            self.input_xlsm_path,
-            self.input_sheet_name,
-            header=0,
-            index_col=None,
-        )
+        df = ParseAsParameter.parse(self.input_xlsm_path, self.input_sheet_name)
 
-        # TODO: 使い勝手を考える
         for i, row in df.iterrows():
-            try:
-                name = row['name']
-                value = row['current']
-                lb = row['lower']
-                ub = row['upper']
-                step = row['step']
-            except KeyError:
-                logger.warn('列名が「name」「current」「lower」「upper」「step」になっていません。この順に並んでいると仮定して処理を続けます。')
-                name, value, lb, ub, step, *_residuals = row.iloc[0]
-
-            name = str(name)
-            value = float(value)
-            lb = float(lb) if not np.isnan(lb) else None
-            ub = float(ub) if not np.isnan(ub) else None
-            step = float(step) if not np.isnan(step) else None
-
-            prm = Parameter(
-                name=name,
-                value=value,
-                lower_bound=lb,
-                upper_bound=ub,
-                step=step,
-                pass_to_fem=True,
-                properties=None,
-            )
-            opt.variables.add_parameter(prm)
+
+            # use(optional)
+            use = True
+            if ParseAsParameter.use in df.columns:
+                _use = row[ParseAsParameter.use]
+                use = False if is_cell_value_empty(_use) else bool(_use)  # bool or NaN
+
+            # name
+            name = str(row[ParseAsParameter.name])
+
+            # value
+            value = float(row[ParseAsParameter.value])
+
+            # lb (optional)
+            lb = None
+            if ParseAsParameter.lb in df.columns:
+                lb = row[ParseAsParameter.lb]
+                lb = None if is_cell_value_empty(lb) else float(lb)
+
+            # ub (optional)
+            ub = None
+            if ParseAsParameter.ub in df.columns:
+                ub = row[ParseAsParameter.ub]
+                ub = None if is_cell_value_empty(ub) else float(ub)
+
+            # step (optional)
+            step = None
+            if ParseAsParameter.step in df.columns:
+                step = row[ParseAsParameter.step]
+                step = None if is_cell_value_empty(step) else float(step)
+
+            if use:
+                prm = Parameter(
+                    name=name,
+                    value=value,
+                    lower_bound=lb,
+                    upper_bound=ub,
+                    step=step,
+                    pass_to_fem=True,
+                    properties=None,
+                )
+                opt.variables.add_parameter(prm)
+
+            else:
+                fixed_prm = Expression(
+                    name=name,
+                    fun=lambda: value,
+                    value=None,
+                    pass_to_fem=True,
+                    properties=dict(
+                        lower_bound=lb,
+                        upper_bound=ub,
+                    ),
+                    kwargs=dict(),
+                )
+                opt.variables.add_expression(fixed_prm)
 
     def load_objective(self, opt):
         from pyfemtet.opt.optimizer import AbstractOptimizer, logger
         from pyfemtet.opt._femopt_core import Objective
         opt: AbstractOptimizer
 
-        df = pd.read_excel(
-            self.output_xlsm_path,
-            self.output_sheet_name,
-            header=0,
-            index_col=None,
-        )
+        df = ParseAsObjective.parse(self.output_xlsm_path, self.output_sheet_name)
 
-        # TODO: 使い勝手を考える
         for i, row in df.iterrows():
+
+            # use(optional)
+            use = True
+            if ParseAsObjective.use in df.columns:
+                _use = row[ParseAsObjective.use]
+                use = False if is_cell_value_empty(_use) else bool(_use)  # bool or NaN
+
+            # name
+            name = str(row[ParseAsObjective.name])
+
+            # direction
+            direction = row[ParseAsObjective.direction]
+            assert not is_cell_value_empty(direction), 'direction is empty.'
             try:
-                name = row['name']
-                _ = row['current']
-                direction = row['direction']
-                value_column_index = list(df.columns).index('current')
-            except KeyError:
-                logger.warn('列名が「name」「current」「direction」になっていません。この順に並んでいると仮定して処理を続けます。')
-                name, _, direction, *_residuals = row.iloc[0]
-                value_column_index = 1
-
-            name = str(name)
-
-            # direction は minimize or maximize or float
-            try:
-                # float or not
                 direction = float(direction)
-
             except ValueError:
-                # 'minimize' or 'maximize
                 direction = str(direction).lower()
-                assert (direction == 'minimize') or (direction == 'maximize')
-
-            # objective を作る
-            opt.objectives[name] = Objective(
-                fun=ScapeGoatObjective(),
-                name=name,
-                direction=direction,
-                args=(i, value_column_index, ),
-                kwargs=dict(),
-            )
-
-    def objective_from_excel(self, i: int, value_column_index: int):
-        r = i + 2  # header が 1
-        c = value_column_index + 1
+                assert direction in ['minimize', 'maximize']
+
+            if use:
+                # objective を作る
+                opt.objectives[name] = Objective(
+                    fun=ScapeGoatObjective(),
+                    name=name,
+                    direction=direction,
+                    args=(name,),
+                    kwargs=dict(),
+                )
+
+    def load_constraint(self, opt):
+        from pyfemtet.opt.optimizer import AbstractOptimizer, logger
+        from pyfemtet.opt._femopt_core import Constraint
+        opt: AbstractOptimizer
+
+        # TODO:
+        #   constraint は optional である。
+        #   現在は実装していないが、シートから問題を取得するよりよいロジックができたら
+        #   （つまり、同じシートからパラメータと拘束を取得出来るようになったら）__init__ 内で
+        #   constraint に None が与えられたのか故意に input_sheet_name と同じシート名を
+        #   与えられたのか分別できる実装に変えてそのチェック処理をここに反映する。
+        # constraint_sheet_name が指定されていない場合何もしない
+        if (self.constraint_sheet_name == self.input_sheet_name) and is_same_path(self.input_xlsm_path, self.constraint_xlsm_path):
+            return
+
+        df = ParseAsConstraint.parse(self.constraint_xlsm_path, self.constraint_sheet_name)
+
+        for i, row in df.iterrows():
+
+            # use(optional)
+            use = True
+            if ParseAsConstraint.use in df.columns:
+                _use = row[ParseAsConstraint.use]
+                use = False if is_cell_value_empty(_use) else bool(_use)  # bool or NaN
+
+            # name
+            name = str(row[ParseAsConstraint.name])
+
+            # lb (optional)
+            lb = None
+            if ParseAsConstraint.lb in df.columns:
+                lb = row[ParseAsConstraint.lb]
+                lb = None if is_cell_value_empty(lb) else float(lb)
+
+            # ub (optional)
+            ub = None
+            if ParseAsConstraint.ub in df.columns:
+                ub = row[ParseAsConstraint.ub]
+                ub = None if is_cell_value_empty(ub) else float(ub)
+
+            # strict (optional)
+            strict = True
+            if ParseAsConstraint.strict in df.columns:
+                _strict = row[ParseAsConstraint.strict]
+                strict = True if is_cell_value_empty(_strict) else bool(_strict)  # bool or NaN
+
+            # using_fem (optional)
+            calc_before_solve = True
+            if ParseAsConstraint.calc_before_solve in df.columns:
+                _calc_before_solve = row[ParseAsConstraint.calc_before_solve]
+                calc_before_solve = True if is_cell_value_empty(_calc_before_solve) else bool(_calc_before_solve)  # bool or NaN
+
+            if use:
+                # constraint を作る
+                opt.constraints[name] = Constraint(
+                    fun=ScapeGoatObjective(),
+                    name=name,
+                    lb=lb,
+                    ub=ub,
+                    strict=strict,
+                    args=(name,),
+                    kwargs=dict(),
+                    using_fem=not calc_before_solve,
+                )
+
+    def objective_from_excel(self, name: str):
+        r = 1 + search_r(self.output_xlsm_path, self.output_sheet_name, name)
+        c = 1 + search_c(self.output_xlsm_path, self.output_sheet_name, ParseAsObjective.value)
         v = self.sh_output.Cells(r, c).value
         return float(v)
 
+    def constraint_from_excel(self, name: str):
+        r = 1 + search_r(self.constraint_xlsm_path, self.constraint_sheet_name, name)
+        c = 1 + search_c(self.constraint_xlsm_path, self.constraint_sheet_name, ParseAsConstraint.value)
+        v = self.sh_constraint.Cells(r, c).value
+        return float(v)
+
 
 def wait_femtet():
     Femtet = Dispatch('FemtetMacro.Femtet')
@@ -757,8 +918,8 @@ def _terminate_femtet(femtet_pid_):
 # main thread で作成した excel への参照を含む関数を
 # 直接 thread や process に渡すと機能しない
 class ScapeGoatObjective:
-    def __call__(self, *args, fem: ExcelInterface or None = None, **kwargs):
-        fem.objective_from_excel(*args, **kwargs)
+    # def __call__(self, *args, fem: ExcelInterface or None = None, **kwargs):
+    #     fem.objective_from_excel(*args, **kwargs)
 
     @property
     def __globals__(self):
@@ -771,6 +932,17 @@ def is_same_path(p1, p2):
     return _p1 == _p2
 
 
+def is_cell_value_empty(cell_value):
+    if isinstance(cell_value, str):
+        return cell_value == ''
+    elif isinstance(cell_value, int) \
+            or isinstance(cell_value, float):
+        return np.isnan(cell_value)
+    elif cell_value is None:
+        return True
+    else:
+        return False
+
 
 if __name__ == '__main__':
     ExcelInterface(..., ...)