PyFemtet 0.3.7__tar.gz → 0.3.9__tar.gz

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfemtet
-Version: 0.3.7
+Version: 0.3.9
 Summary: Design parameter optimization using Femtet.
 Home-page: https://github.com/pyfemtet/pyfemtet
 License: BSD-3-Clause

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/FemtetPJTSample/NX_ex01/NX_ex01.py

@@ -85,4 +85,4 @@ if __name__ == '__main__':
 
     # 最適化の実行
     femopt.set_random_seed(42)
-    femopt.main(n_trials=20, n_parallel=3)
+    femopt.main(n_trials=20)

pyfemtet-0.3.9/pyfemtet/FemtetPJTSample/Sldworks_ex01/Sldworks_ex01.py

@@ -0,0 +1,99 @@
+"""外部 CAD ソフト Solidworks との連携
+
+外部 CAD ソフト Solidworks で作成したパラメトリックモデルを
+Femtet にインポートして最適化を行います。
+
+事前準備として、以下の作業を行ってください。
+    - Sldworks_ex01.SLDPRT と Sldworks_ex01.femprj を同じフォルダに配置する
+    - C:\temp フォルダを作成する
+        ※ 最適化の実行中に Solidworks から .x_t ファイルがエクスポートされます。
+"""
+
+import os
+from pyfemtet.opt import FEMOpt, OptunaOptimizer
+from pyfemtet.opt.interface import FemtetWithSolidworksInterface
+from pyfemtet.core import ModelError
+
+
+here, me = os.path.split(__file__)
+os.chdir(here)
+
+
+def disp(Femtet):
+    """解析結果から Z 方向最大変位を取得します。
+    目的関数の第一引数は Femtet インスタンスである必要があります。
+    """
+    _, _, ret = Femtet.Gogh.Galileo.GetMaxDisplacement_py()
+
+    # CAD 連携の場合、境界条件をトポロジーIDに基づいて割り当てているので、
+    # 意図しない箇所に境界条件が割り当てられることがあります。
+    # この問題では意図通りの割り当てができていれば最大変位は必ず負なので
+    # 答えが正の場合は境界条件割り当てに失敗しているとみなして
+    # ModelError を送出するようにします。
+    # 最適化ルーチン中に ModelError, MeshError, SolveError が送出された場合
+    # Optimizer はその試行を失敗とみなし、スキップして次の試行を行います。
+    if ret >= 0:
+        raise ModelError('境界条件の割り当てが間違えています。')
+    return ret
+
+
+def volume(Femtet):
+    """解析結果からモデル体積を取得します。
+    目的関数の第一引数は Femtet インスタンスである必要があります。
+    """
+    _, ret = Femtet.Gogh.CalcVolume_py([0])
+    return ret
+
+
+def C_minus_B(_, opt):
+    """C 寸法と B 寸法の差を計算します。
+
+    拘束関数の第一引数は Femtet インスタンスである必要がありますが、
+    この例では使用していません。
+
+    ほかの例では設計変数にアクセスする際以下のスニペットを用いますが、
+    CAD 連携を行う場合、Femtet に設計変数が設定されていないためです。
+        A = Femtet.GetVariableValue('A')
+
+    pyfemtet.opt では目的関数・拘束関数の第二引数以降に任意の変数を設定できます。
+    この例では、第二引数に FEMOpt のメンバー変数 opt を取り、
+    そのメソッド get_parameter() を用いて設計変数を取得しています。
+
+    """
+    A, B, C = opt.get_parameter('values')
+    return C - B
+
+
+if __name__ == '__main__':
+
+    # Solidworks-Femtet 連携オブジェクトを用意
+    # ここで起動している Femtet と紐づけがされます。
+    fem = FemtetWithSolidworksInterface(
+        sldprt_path='Sldworks_ex01.SLDPRT',
+        femprj_path='Sldworks_ex01.femprj',
+    )
+
+    opt = OptunaOptimizer(
+        sampler_kwargs=dict(
+            n_startup_trials=5,
+        )
+    )
+
+    # 最適化処理を行うオブジェクトに連携オブジェクトを紐づけ
+    femopt = FEMOpt(fem=fem, opt=opt)
+
+    # 設計変数の設定
+    femopt.add_parameter('A', 10, lower_bound=1, upper_bound=59)
+    femopt.add_parameter('B', 10, lower_bound=1, upper_bound=40)
+    femopt.add_parameter('C', 20, lower_bound=5, upper_bound=59)
+
+    # 拘束関数の設定
+    femopt.add_constraint(C_minus_B, 'C>B', lower_bound=1, args=femopt.opt)
+
+    # 目的関数の設定
+    femopt.add_objective(disp, name='変位', direction=0)
+    femopt.add_objective(volume, name='体積', direction='minimize')
+
+    # 最適化の実行
+    femopt.set_random_seed(42)
+    femopt.main(n_trials=20)

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/FemtetPJTSample/gau_ex08_parametric.py

@@ -34,7 +34,6 @@ if __name__ == '__main__':
     opt = OptunaOptimizer(
         sampler_class=BoTorchSampler,
         sampler_kwargs=dict(
-            consider_running_trials=True,
             n_startup_trials=5,
         )
     )

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/FemtetPJTSample/her_ex40_parametric.py

@@ -112,7 +112,6 @@ if __name__ == '__main__':
     opt = OptunaOptimizer(
         sampler_class=BoTorchSampler,
         sampler_kwargs=dict(
-            consider_running_trials=True,
             n_startup_trials=5,
         )
     )

pyfemtet-0.3.9/pyfemtet/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.9"

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/dispatch_extensions.py

@@ -144,12 +144,12 @@ def _get_subprocess_log_prefix():
     return f'({current_process().name}) '
 
 
-def launch_and_dispatch_femtet(timeout=DISPATCH_TIMEOUT, strict_pid_specify=True) -> Tuple[IFemtet, int]:
+def launch_and_dispatch_femtet(timeout=DISPATCH_TIMEOUT, strictly_pid_specify=True) -> Tuple[IFemtet, int]:
     """Launch Femtet by new process and connect to it.
 
     Args:
         timeout (int or float, optional): Seconds to wait for connection. Defaults to DISPATCH_TIMEOUT.
-        strict_pid_specify (bool): If True, try to connect the launched femtet process strictly. If False, launch new process but try to connect any connectable femtet.
+        strictly_pid_specify (bool): If True, try to connect the launched femtet process strictly. If False, launch new process but try to connect any connectable femtet.
 
     Raises:
         FemtetNotFoundException: Launched Femtet is not found for some reason (i.e. failed to launch Femtet).
@@ -166,7 +166,7 @@ def launch_and_dispatch_femtet(timeout=DISPATCH_TIMEOUT, strict_pid_specify=True
         sleep(1)
 
     # dispatch femtet
-    if strict_pid_specify:
+    if strictly_pid_specify:
         Femtet, pid = dispatch_specific_femtet(pid, timeout)
     else:
         # worker process なら排他処理する
@@ -350,6 +350,7 @@ def dispatch_specific_femtet_core(pid, timeout=DISPATCH_TIMEOUT) -> Tuple[IFemte
         If you have 2 free Femtet processes (their pid is 1000 and 1001),
         you can only connect to first connected Femtet
         and cannot change the connection.
+
         >>> from pyfemtet.dispatch_extensions import dispatch_specific_femtet
         >>> Femtet1, pid1 = dispatch_specific_femtet(pid=1000)
         >>> print(pid1)  # 1000
@@ -361,28 +362,6 @@ def dispatch_specific_femtet_core(pid, timeout=DISPATCH_TIMEOUT) -> Tuple[IFemte
         If you want to connect 2 more Femtet processes from single script or interprete,
         please consider parallel processing.
 
-    Code:
-
-        from multiprocessing import Process
-        from pyfemtet.dispatch_extensions import dispatch_specific_femtet
-
-        def connect_femtet(pid):
-            Femtet, pid = dispatch_specific_femtet(pid=pid)
-            ...  # some processing
-
-        if __name__ == '__main__':
-            # setup parallel processing
-            p1 = Process(target=connect_femtet, args=(1000,))
-            p2 = Process(target=connect_femtet, args=(1001,))
-
-            # start parallel processing
-            p1.start()
-            p2.start()
-
-            # wait for finish processes
-            p1.join()
-            p2.join()
-
     Args:
         pid (int): Process id of Femtet that you want to connect.
         timeout (int or float, optional): Seconds to wait for connection. Defaults to 10.

pyfemtet-0.3.9/pyfemtet/opt/__init__.py

@@ -0,0 +1,2 @@
+from .base import FEMOpt, OptunaOptimizer
+from .interface import FemtetInterface, NoFEM, FemtetWithNXInterface, FemtetWithSolidworksInterface

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/opt/base.py

@@ -204,9 +204,6 @@ class Function:
     def calc(self, fem: FEMInterface):
         """Execute user-defined fun.
 
-        If fem is a FemtetInterface,
-        the 1st argument of fun is set to fem automatically.
-
         Args:
             fem (FEMInterface)
 
@@ -246,6 +243,11 @@ class Objective(Function):
         Raises:
             ValueError: If the direction is not valid.
 
+        Note:
+            If FEMOpt.fem is a instance of FemtetInterface or its subclass,
+            the 1st argument of fun is set to fem automatically.
+
+
         """
         _check_direction(direction)
         self.direction = direction
@@ -257,7 +259,7 @@ class Objective(Function):
         When direction is `'minimize'`, ``value`` is calculated.
         When direction is `'maximize'`, ``-value`` is calculated.
         When direction is float, ``abs(value - direction)`` is calculated.
-        Finally, the calculated value is passed to the symlog function.
+        Finally, the calculated value is passed to the symlog function and returns it.
 
         ``value`` is the return value of the user-defined function.
 
@@ -312,7 +314,7 @@ class Constraint(Function):
         super().__init__(fun, name, args, kwargs)
 
 
-class HistoryDfCore:
+class _HistoryDfCore:
     """Class for managing a DataFrame object in a distributed manner."""
 
     def __init__(self):
@@ -334,6 +336,7 @@ class History:
         param_names (list): The names of the parameters in the study.
         obj_names (list): The names of the objectives in the study.
         cns_names (list): The names of the constraints in the study.
+        actor_data (pd.DataFrame): The history data of optimization.
 
     """
     def __init__(self, history_path, client):
@@ -347,7 +350,7 @@ class History:
         # 引数の処理
         self.path = history_path  # .csv
         self.is_restart = False
-        self._future = client.submit(HistoryDfCore, actor=True)
+        self._future = client.submit(_HistoryDfCore, actor=True)
         self._actor_data = self._future.result()
         self.tmp_data = pd.DataFrame()
         self.param_names = []
@@ -544,7 +547,7 @@ class History:
                     df.loc[i, 'hypervolume'] = 0
 
 
-class OptimizationStatusActor:
+class _OptimizationStatusActor:
     status_int = -1
     status = 'undefined'
 
@@ -554,11 +557,7 @@ class OptimizationStatusActor:
 
 
 class OptimizationStatus:
-    """Optimization status.
-
-    undefined -> setting up -> launching -> running (-> interrupting) -> terminated
-
-    """
+    """Optimization status."""
     UNDEFINED = -1
     INITIALIZING = 0
     SETTING_UP = 10
@@ -571,7 +570,7 @@ class OptimizationStatus:
     TERMINATE_ALL = 60
 
     def __init__(self, client, name='entire'):
-        self._future = client.submit(OptimizationStatusActor, actor=True)
+        self._future = client.submit(_OptimizationStatusActor, actor=True)
         self._actor = self._future.result()
         self.name = name
         self.set(self.INITIALIZING)
@@ -606,6 +605,25 @@ class OptimizationStatus:
 
 
 class AbstractOptimizer(ABC):
+    """Abstract base class for an interface of optimization library.
+        
+    Attributes:
+        fem (FEMInterface): The finite element method object.
+        fem_class (type): The class of the finite element method object.
+        fem_kwargs (dict): The keyword arguments used to instantiate the finite element method object.
+        parameters (pd.DataFrame): The parameters used in the optimization.
+        objectives (dict): A dictionary containing the objective functions used in the optimization.
+        constraints (dict): A dictionary containing the constraint functions used in the optimization.
+        entire_status (OptimizationStatus): The status of the entire optimization process.
+        history (History): An actor object that records the history of each iteration in the optimization process.
+        worker_status (OptimizationStatus): The status of each worker in a distributed computing environment.
+        message (str): A message associated with the current state of the optimization process.
+        seed (int or None): The random seed used for random number generation during the optimization process.
+        timeout (float or int or None): The maximum time allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
+        n_trials (int or None): The maximum number of trials allowed for each iteration of the optimization process. If exceeded, it will be interrupted and terminated early.
+        is_cluster (bool): Flag indicating if running on a distributed computing cluster.    
+    
+    """
 
     def __init__(self):
         self.fem = None
@@ -624,6 +642,7 @@ class AbstractOptimizer(ABC):
         self.is_cluster = False
 
     def f(self, x):
+        """Get x, update fem analysis, return objectives (and constraints)."""
         # interruption の実装は具象クラスに任せる
 
         # x の更新
@@ -657,6 +676,7 @@ class AbstractOptimizer(ABC):
         return np.array(y), np.array(_y), np.array(c)
 
     def set_fem(self, skip_reconstruct=False):
+        """Reconstruct FEMInterface in a subprocess."""
         # restore fem
         if not skip_reconstruct:
             self.fem = self.fem_class(**self.fem_kwargs)
@@ -692,7 +712,8 @@ class AbstractOptimizer(ABC):
         else:
             raise ValueError('get_parameter() got invalid format: {format}')
 
-    def check_interruption(self):
+    def _check_interruption(self):
+        """"""
         if self.entire_status.get() == OptimizationStatus.INTERRUPTING:
             self.worker_status.set(OptimizationStatus.INTERRUPTING)
             self.finalize()
@@ -701,6 +722,7 @@ class AbstractOptimizer(ABC):
             return False
 
     def finalize(self):
+        """Destruct fem and set worker status."""
         del self.fem
         self.worker_status.set(OptimizationStatus.TERMINATED)
 
@@ -716,25 +738,26 @@ class AbstractOptimizer(ABC):
         self.worker_status = worker_status_list[subprocess_idx]
         self.worker_status.set(OptimizationStatus.LAUNCHING_FEM)
 
-        if self.check_interruption():
+        if self._check_interruption():
             return None
 
         # set_fem をはじめ、終了したらそれを示す
         if not skip_set_fem:  # なくても動く？？
             self.set_fem()
+        self.fem.setup_after_parallel()
         self.worker_status.set(OptimizationStatus.WAIT_OTHER_WORKERS)
 
         # wait_setup or not
         if wait_setup:
             while True:
-                if self.check_interruption():
+                if self._check_interruption():
                     return None
                 # 他のすべての worker_status が wait 以上になったら break
                 if all([ws.get() >= OptimizationStatus.WAIT_OTHER_WORKERS for ws in worker_status_list]):
                     break
                 sleep(1)
         else:
-            if self.check_interruption():
+            if self._check_interruption():
                 return None
 
         # set status running
@@ -752,12 +775,12 @@ class AbstractOptimizer(ABC):
 
     @abstractmethod
     def main(self, subprocess_idx: int = 0) -> None:
-        """Called from dask worker."""
+        """Start calcuration using optimization library."""
         pass
 
     @abstractmethod
     def setup_before_parallel(self, *args, **kwargs):
-        """Preprocessing for dask parallel workers."""
+        """Setup before parallel processes are launched."""
         pass
 
 
@@ -779,7 +802,6 @@ class OptunaOptimizer(AbstractOptimizer):
         self.additional_initial_parameter = []
         self.additional_initial_methods = add_init_method if hasattr(add_init_method, '__iter__') else [add_init_method]
 
-
     def _objective(self, trial):
 
         # 中断の確認 (FAIL loop に陥る対策)
@@ -820,7 +842,7 @@ class OptunaOptimizer(AbstractOptimizer):
         try:
             _, _y, c = self.f(x)
         except (ModelError, MeshError, SolveError) as e:
-            logger.info(str(type(e)).split("'")[1].split('.')[-1], e)
+            logger.info(e)
             logger.info('以下の変数で FEM 解析に失敗しました。')
             print(self.get_parameter('dict'))
 
@@ -855,7 +877,7 @@ class OptunaOptimizer(AbstractOptimizer):
         return trial.user_attrs['constraint'] if 'constraint' in trial.user_attrs.keys() else (1,)  # infeasible
 
     def setup_before_parallel(self):
-        """Main process から呼ばれる関数"""
+        """Create storage, study and set initial parameter."""
 
         # create storage
         self.study_name = os.path.basename(self.history.path)
@@ -951,7 +973,7 @@ class OptunaOptimizer(AbstractOptimizer):
         self.additional_initial_parameter.append([parameter, name])
 
     def main(self, subprocess_idx=0):
-        """Dask worker から呼ばれる関数"""
+        """Set random seed, sampler, study and run study.optimize()."""
 
         # (re)set random seed
         seed = self.seed
@@ -1167,7 +1189,8 @@ class FEMOpt:
             lower_bound (float or Non, optional): The lower bound of the constraint. Defaults to None.
             upper_bound (float or Non, optional): The upper bound of the constraint. Defaults to None.
             strict (bool, optional): Flag indicating if it is a strict constraint. Defaults to True.
-            args (tuple or None, optional): Additional arguments for the constraint function. Defaults toNone.
+            args (tuple or None, optional): Additional arguments for the constraint function. Defaults to None.
+            kwargs (dict): Additional arguments for the constraint function. Defaults to None.
 
         Note:
             If the FEMInterface is FemtetInterface, the 1st argument of fun should be Femtet (IPyDispatch) object.
@@ -1229,10 +1252,13 @@ class FEMOpt:
             port (int or None, optional): The port number of the monitor server. If None, ``8080`` will be used. Defaults to None.
 
         Tip:
-            If host is ``0.0.0.0``, a server will be set up
-            that is visible from the local network.
-            Start a browser on another machine
-            and type ``<ip_address_or_hostname>:<port>`` in the address bar.
+            If you do not know the host IP address
+            for connecting to the local network,
+            use the ``ipconfig`` command to find out.
+            
+            Alternatively, you can specify host as 0.0.0.0
+            to access the monitor server through all network interfaces
+            used by that computer.        
 
             However, please note that in this case,
             it will be visible to all users on the local network.
@@ -1262,15 +1288,14 @@ class FEMOpt:
             If setup_monitor_server() is not executed, a local server for monitoring will be started at localhost:8080.
 
         Note:
-            If ``n_trials`` and ``timeout`` are both None, it will calculate repeatedly until interrupting by the user.
+            If ``n_trials`` and ``timeout`` are both None, it runs forever until interrupting by the user.
         
         Note:
             If ``n_parallel`` >= 2, depending on the end timing, ``n_trials`` may be exceeded by up to ``n_parallel-1`` times.
 
-        Note:
-            Currently, supported methods are 'TPE' and 'botorch'.
-            For detail, see https://optuna.readthedocs.io/en/stable/reference/samplers/index.html.
-
+        Warning:
+            If ``n_parallel`` >= 2 and ``fem`` is a subclass of ``FemtetInterface``, the ``strictly_pid_specify`` of subprocess is set to ``False``.
+            So **it is recommended to close all other Femtet processes before running main().**
 
         """
 
@@ -1323,19 +1348,9 @@ class FEMOpt:
             list(self.opt.constraints.keys()),
         )
 
-        # fem
-        self.fem.setup_before_parallel(self.client)
-
-        # opt
-        self.opt.fem_class = type(self.fem)
-        self.opt.fem_kwargs = self.fem.kwargs
-        self.opt.entire_status = self.status
-        self.opt.history = self.history
-        self.opt.setup_before_parallel()
-
         # launch monitor
         self.monitor_process_future = self.client.submit(
-            start_monitor_server_forever,
+            start_monitor_server,
             self.history,
             self.status,
             worker_addresses,
@@ -1345,6 +1360,16 @@ class FEMOpt:
             allow_other_workers=False
         )
 
+        # fem
+        self.fem.setup_before_parallel(self.client)
+
+        # opt
+        self.opt.fem_class = type(self.fem)
+        self.opt.fem_kwargs = self.fem.kwargs
+        self.opt.entire_status = self.status
+        self.opt.history = self.history
+        self.opt.setup_before_parallel()
+
         # クラスターでの計算開始
         self.status.set(OptimizationStatus.LAUNCHING_FEM)
         start = time()
@@ -1407,6 +1432,11 @@ class FEMOpt:
         logger.info(f'結果は{self.history.path}を確認してください.')
 
     def terminate_all(self):
+        """Try to terminate all launched processes.
+        
+        If distributed computing, Scheduler and Workers will NOT be terminated.
+        
+        """
 
         # monitor が terminated 状態で少なくとも一度更新されなければ running のまま固まる
         sleep(1)
@@ -1453,7 +1483,7 @@ class FEMOpt:
         sleep(3)
 
 
-def start_monitor_server_forever(history, status, worker_addresses, worker_status_list, host='localhost', port=8080):
+def start_monitor_server(history, status, worker_addresses, worker_status_list, host='localhost', port=8080):
     monitor = Monitor(history, status, worker_addresses, worker_status_list)
     monitor.start_server(worker_addresses, worker_status_list, host, port)
     return 'Exit monitor server process gracefully'

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyfemtet/opt/interface.py

@@ -1,16 +1,19 @@
 import os
+import re
 import sys
 from time import sleep, time
 import json
 import subprocess
 import signal
+from abc import ABC, abstractmethod
 
 import pandas as pd
 import psutil
 from pywintypes import com_error
 from pythoncom import CoInitialize, CoUninitialize
-from win32com.client import constants, Dispatch
+from win32com.client import constants, DispatchEx
 from dask.distributed import get_worker
+from tqdm import trange
 from femtetutils import util
 
 from ..core import (
@@ -34,7 +37,7 @@ logger.setLevel(logging.INFO)
 here, me = os.path.split(__file__)
 
 
-class FEMInterface:
+class FEMInterface(ABC):
     """Abstract base class for the interface with FEM software."""
 
     def __init__(
@@ -46,59 +49,28 @@ class FEMInterface:
         The concrete class should call super().__init__() with the desired arguments when restoring.
 
         Args:
-            subprocess_idx (int or None, optional): The index of the subprocess. Defaults to None.
-            subprocess_settings ('Any' or None, optional): Additional settings for the subprocess. Defaults to None.
-            **kwargs: keyword arguments for FEMInterface constructor.
+            **kwargs: keyword arguments for FEMInterface (re)constructor.
 
         """
         # restore のための情報保管
         self.kwargs = kwargs
 
-    def check_param_value(self, param_name) -> float:
-        """Checks the value of a parameter in the FEM model.
-
-        Args:
-            param_name (str): The name of the parameter.
-
-        Raises:
-            Exception: If param_name does not exist in the FEM model.
-
-        Returns:
-            float: The value of the parameter.
-
-        """
-        return 0.0
-
+    @abstractmethod
     def update(self, parameters: pd.DataFrame) -> None:
-        """Updates the FEM analysis based on the proposed parameters.
-
-        Args:
-            parameters (pd.DataFrame): The parameters to be updated. Must have at least 'name' and 'value'.
+        """Updates the FEM analysis based on the proposed parameters."""
+        raise NotImplementedError('update() must be implemented.')
 
-         Raises:
-            ModelError, MeshError, SolveError: If there are errors in updating or analyzing the model.
-
-         Returns:
-            None
-
-         """
-        pass
+    def check_param_value(self, param_name) -> float or None:
+        """Checks the value of a parameter in the FEM model (if implemented in concrete class)."""
+        if False:
+            raise RuntimeError(f"{param_name} doesn't exist on FEM model.")
 
     def update_parameter(self, parameters: pd.DataFrame) -> None:
-        """Updates only FEM variables that can be obtained with Femtet.GetVariableValue and similar functions.
-
-        If users define a function to be passed to add_objective etc. to take OptimizerBase as an argument,
-        and access the variable by calling OptimizerBase.get_parameter() within the function,
-        there is no need to implement this method in the concrete class of FEMInterface.
-
-        Args:
-         parameters (pd.DataFrame): The parameters to be updated.
-
-        """
+        """Updates only FEM variables (if implemented in concrete class)."""
         pass
 
     def setup_before_parallel(self, client) -> None:
-        """Preprocessing before launching a dask worker.
+        """Preprocessing before launching a dask worker (if implemented in concrete class).
 
         Args:
             client: dask client.
@@ -110,30 +82,42 @@ class FEMInterface:
         """
         pass
 
+    def setup_after_parallel(self):
+        """Preprocessing after launching a dask worker and before run optimization (if implemented in concrete class)."""
+        pass
 
-class FemtetInterface(FEMInterface):
-    """Concrete class for the interface with Femtet software."""    
-
-    def __init__(
-            self,
-            femprj_path=None,
-            model_name=None,
-            connect_method='auto',
-            strict_pid_specify=False,
-            **kwargs
-    ):
-        """Initializes the FemtetInterface.
 
+class FemtetInterface(FEMInterface):
+    """Concrete class for the interface with Femtet software.
+    
         Args:
             femprj_path (str or None, optional): The path to the .femprj file. Defaults to None.
             model_name (str or None, optional): The name of the analysis model. Defaults to None.
             connect_method (str, optional): The connection method to use. Can be 'new', 'existing', or 'auto'. Defaults to 'auto'.
-            strict_pid_specify (bool): If True and connect_method=='new', search launched Femtet process strictly based on its process id. This option requires large overhead time. So It is recommended to set False in large n_parallel.
+            strictly_pid_specify (bool, optional): If True and connect_method=='new', search launched Femtet process strictly based on its process id.
+
+        Warning:
+            Even if you specify ``strictly_pid_specify=True`` on the constructor,
+            **the connection behavior is like** ``strictly_pid_specify=False`` **in parallel processing**
+            because of its large overhead.
+            So you should close all Femtet processes before running FEMOpt.main()
+            if ``n_parallel`` >= 2.
+
+
 
         Tip:
             If you search for information about the method to connect python and Femtet, see :func:`connect_femtet`.
+    
+    """    
 
-        """
+    def __init__(
+            self,
+            femprj_path=None,
+            model_name=None,
+            connect_method='auto',
+            strictly_pid_specify=True,
+            **kwargs  # 継承されたクラスからの引数
+    ):
 
         # win32com の初期化
         CoInitialize()
@@ -152,7 +136,7 @@ class FemtetInterface(FEMInterface):
         self.connected_method = 'unconnected'
         self.parameters = None
         self.max_api_retry = 3
-        self.strict_pid_specify = strict_pid_specify
+        self.strictly_pid_specify = strictly_pid_specify
 
         # dask サブプロセスのときは femprj を更新し connect_method を new にする
         try:
@@ -161,6 +145,7 @@ class FemtetInterface(FEMInterface):
             # worker なら femprj_path が None でないはず
             self.femprj_path = os.path.join(space, os.path.basename(self.femprj_path))
             self.connect_method = 'new'
+            self.strictly_pid_specify = False
         except ValueError:  # get_worker に失敗した場合
             pass
 
@@ -171,13 +156,12 @@ class FemtetInterface(FEMInterface):
         # 接続した Femtet の種類に応じて del 時に quit するかどうか決める
         self.quit_when_destruct = self.connected_method == 'new'
 
-        # restore するための情報保管
+        # subprocess で restore するための情報保管
         # パスなどは connect_and_open_femtet での処理結果を反映し
         # メインで開いた解析モデルが確実に開かれるようにする
         super().__init__(
             femprj_path=self.femprj_path,
             model_name=self.model_name,
-            strict_pid_specify=self.strict_pid_specify,
             **kwargs
         )
 
@@ -203,7 +187,7 @@ class FemtetInterface(FEMInterface):
     def _connect_new_femtet(self):
         logger.info('└ Try to launch and connect new Femtet process.')
 
-        self.Femtet, _ = launch_and_dispatch_femtet(strict_pid_specify=self.strict_pid_specify)
+        self.Femtet, _ = launch_and_dispatch_femtet(strictly_pid_specify=self.strictly_pid_specify)
 
         self.connected_method = 'new'
 
@@ -219,21 +203,25 @@ class FemtetInterface(FEMInterface):
 
     def connect_femtet(self, connect_method: str = 'auto', pid: int or None = None):
         """Connects to a Femtet process.
+
         Args:
             connect_method (str, optional): The connection method. Can be 'new', 'existing', or 'auto'. Defaults to 'new'.
             pid (int or None, optional): The process ID of an existing Femtet process and wanted to connect.
 
-        When connect_method is 'new', starts a new Femtet process and connects to it.
-        **`pid` will be ignored.**
+        Note:
+            When connect_method is 'new', starts a new Femtet process and connects to it.
+            **`pid` will be ignored.**
 
-        When 'existing', connect to an existing Femtet process.
-        However, if there are no Femtets to which it can connect
-        (i.e. already connected to another Python or Excel process),
-        it throws an exception.
+        Note:
+            When 'existing', connect to an existing Femtet process.
+            However, if there are no Femtets to which it can connect
+            (i.e. already connected to another Python or Excel process),
+            it throws an exception.
 
-        When set to 'auto', first tries 'existing', and if that fails, connects with 'new'.
-        If `pid` is specified and failed to connect,
-        it will not try existing another Femtet process.
+        Note:
+            When set to 'auto', first tries 'existing', and if that fails, connects with 'new'.
+            If `pid` is specified and failed to connect,
+            it will not try existing another Femtet process.
 
         """
 
@@ -400,6 +388,7 @@ class FemtetInterface(FEMInterface):
                 )
 
     def femtet_is_alive(self) -> bool:
+        """Returns connected femtet process is exsiting or not."""
         return _get_pid(self.Femtet.hWnd) > 0
 
     def open(self, femprj_path: str, model_name: str or None = None) -> None:
@@ -598,12 +587,21 @@ class FemtetInterface(FEMInterface):
 
 class NoFEM(FEMInterface):
     """Interface with no FEM for debug."""
-    pass
+    def update(self, parameters: pd.DataFrame) -> None:
+        pass
 
 
 class FemtetWithNXInterface(FemtetInterface):
+    """Femtet with NX interface class.
+
+    Args:
+        prt_path: The path to the prt file.
+    
+    For details of The other arguments, see ``FemtetInterface``.
+
+    """
 
-    JOURNAL_PATH = os.path.abspath(os.path.join(here, '_FemtetWithNX/update_model.py'))
+    _JOURNAL_PATH = os.path.abspath(os.path.join(here, '_FemtetWithNX/update_model.py'))
 
     def __init__(
             self,
@@ -611,21 +609,8 @@ class FemtetWithNXInterface(FemtetInterface):
             femprj_path=None,
             model_name=None,
             connect_method='auto',
+            strictly_pid_specify=True,
     ):
-        """
-        Initializes the FemtetWithNXInterface class.
-
-        Args:
-            prt_path: The path to the prt file.
-            femprj_path: The path to the femprj file (optional).
-            model_name: The name of the model (optional).
-            connect_method: The connection method (default 'auto').
-            subprocess_idx: The subprocess index (optional).
-            subprocess_settings: The subprocess settings (optional).
-
-        Returns:
-            None
-        """
 
         # check NX installation
         self.run_journal_path = os.path.join(os.environ.get('UGII_BASE_DIR'), 'NXBIN', 'run_journal.exe')
@@ -635,33 +620,44 @@ class FemtetWithNXInterface(FemtetInterface):
         # 引数の処理
         self.prt_path = os.path.abspath(prt_path)
 
+        # dask サブプロセスのときは prt_path を worker space から取るようにする
+        try:
+            worker = get_worker()
+            space = worker.local_directory
+            # worker なら femprj_path が None でないはず
+            self.prt_path = os.path.join(space, os.path.basename(self.prt_path))
+        except ValueError:  # get_worker に失敗した場合
+            pass
+
         # FemtetInterface の設定 (femprj_path, model_name の更新など)
         # + restore 情報の上書き
         super().__init__(
             femprj_path=femprj_path,
             model_name=model_name,
             connect_method=connect_method,
-            prt_path=os.path.basename(prt_path)  # upload_file でアップロードされたファイルへのパスになる
+            strictly_pid_specify=strictly_pid_specify,
+            prt_path=self.prt_path,
         )
 
 
     def check_param_value(self, name):
-        # desable FemtetInterface.check_param_value()
-        # because the parameter can be registered to not only .femprj but also .prt.
-        return None
+        """Override FemtetInterface.check_param_value().
+        
+        Do nothing because the parameter can be registered
+        to not only .femprj but also .prt.
+        
+        """
+        pass
 
     def setup_before_parallel(self, client):
-        client.upload_file(
-            self.kwargs['femprj_path'],
-            False
-        )
         client.upload_file(
             self.kwargs['prt_path'],
             False
         )
+        super().setup_before_parallel(client)
 
     def update_model(self, parameters: 'pd.DataFrame') -> None:
-        """Update .x_t file before FemtetInterface.update_model()"""
+        """Update .x_t"""
 
         self.parameters = parameters.copy()
 
@@ -681,7 +677,7 @@ class FemtetWithNXInterface(FemtetInterface):
         # NX journal を使ってモデルを編集する
         env = os.environ.copy()
         subprocess.run(
-            [self.run_journal_path, self.JOURNAL_PATH, '-args', self.prt_path, str_json, x_t_path],
+            [self.run_journal_path, self._JOURNAL_PATH, '-args', self.prt_path, str_json, x_t_path],
             env=env,
             shell=True,
             cwd=os.path.dirname(self.prt_path)
@@ -713,7 +709,167 @@ class FemtetWithNXInterface(FemtetInterface):
         super().update_model(parameters)
 
 
+class FemtetWithSolidworksInterface(FemtetInterface):
 
-# TODO: SW-Femtet 再実装
+    # 定数の宣言
+    swThisConfiguration = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
+    swAllConfiguration = 2
+    swSpecifyConfiguration = 3  # use with ConfigName argument
+    swSaveAsCurrentVersion = 0
+    swSaveAsOptions_Copy = 2  #
+    swSaveAsOptions_Silent = 1  # https://help.solidworks.com/2021/english/api/swconst/solidworks.interop.swconst~solidworks.interop.swconst.swsaveasoptions_e.html
+    swSaveWithReferencesOptions_None = 0  # https://help-solidworks-com.translate.goog/2023/english/api/swconst/SolidWorks.Interop.swconst~SolidWorks.Interop.swconst.swSaveWithReferencesOptions_e.html?_x_tr_sl=auto&_x_tr_tl=ja&_x_tr_hl=ja&_x_tr_pto=wapp
+    swDocPART = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swDocumentTypes_e.html
 
+    def __init__(
+            self,
+            sldprt_path,
+            femprj_path=None,
+            model_name=None,
+            connect_method='auto',
+            strictly_pid_specify=True,
+    ):
+        # 引数の処理
+        self.sldprt_path = os.path.abspath(sldprt_path)
 
+        # dask サブプロセスのときは prt_path を worker space から取るようにする
+        try:
+            worker = get_worker()
+            space = worker.local_directory
+            # worker なら femprj_path が None でないはず
+            self.prt_path = os.path.join(space, os.path.basename(self.prt_path))
+        except ValueError:  # get_worker に失敗した場合
+            pass
+
+        # FemtetInterface の設定 (femprj_path, model_name の更新など)
+        # + restore 情報の上書き
+        super().__init__(
+            femprj_path=femprj_path,
+            model_name=model_name,
+            connect_method=connect_method,
+            strictly_pid_specify=strictly_pid_specify,
+            sldprt_path=self.sldprt_path,
+        )
+
+    def initialize_sldworks_connection(self):
+        # SolidWorks を捕まえ、ファイルを開く
+        self.swApp = DispatchEx('SLDWORKS.Application')
+        self.swApp.Visible = True
+
+        # open model
+        self.swApp.OpenDoc(self.sldprt_path, self.swDocPART)
+        self.swModel = self.swApp.ActiveDoc
+        self.swEqnMgr = self.swModel.GetEquationMgr
+        self.nEquation = self.swEqnMgr.GetCount
+
+    def check_param_value(self, param_name):
+        """Override FemtetInterface.check_param_value().
+        
+        Do nothing because the parameter can be registered
+        to not only .femprj but also .SLDPRT.
+        
+        """
+        pass
+
+    def setup_before_parallel(self, client):
+        client.upload_file(
+            self.kwargs['sldprt_path'],
+            False
+        )
+        super().setup_before_parallel(client)
+
+    def setup_after_parallel(self):
+        CoInitialize()
+        self.initialize_sldworks_connection()
+
+    def update_model(self, parameters: pd.DataFrame):
+        """Update .x_t"""
+
+        self.parameters = parameters.copy()
+
+        # Femtet が参照している x_t パスを取得する
+        x_t_path = self.Femtet.Gaudi.LastXTPath
+
+        # 前のが存在するならば消しておく
+        if os.path.isfile(x_t_path):
+            os.remove(x_t_path)
+
+        # solidworks のモデルの更新
+        self.update_sw_model(parameters)
+
+        # export as x_t
+        self.swModel.SaveAs(x_t_path)
+
+        # 30 秒待っても x_t ができてなければエラー(COM なので)
+        timeout = 30
+        start = time()
+        while True:
+            if os.path.isfile(x_t_path):
+                break
+            if time()-start > timeout:
+                raise ModelError('モデル再構築に失敗しました')
+            sleep(1)
+
+        # モデルの再インポート
+        self._call_femtet_api(
+            self.Femtet.Gaudi.ReExecute,
+            False,
+            ModelError,  # 生きてるのに失敗した場合
+            error_message=f'モデル再構築に失敗しました.',
+            is_Gaudi_method=True,
+        )
+
+        # 処理を確定
+        self._call_femtet_api(
+            self.Femtet.Redraw,
+            False,  # 戻り値は常に None なのでこの変数に意味はなく None 以外なら何でもいい
+            ModelError,  # 生きてるのに失敗した場合
+            error_message=f'モデル再構築に失敗しました.',
+            is_Gaudi_method=True,
+        )
+
+        # femprj モデルの変数も更新
+        super().update_model(parameters)
+
+    def update_sw_model(self, parameters: pd.DataFrame):
+        """Update .sldprt"""
+        # df を dict に変換
+        user_param_dict = {}
+        for i, row in parameters.iterrows():
+            user_param_dict[row['name']] = row['value']
+
+        # プロパティを退避
+        buffer_aso = self.swEqnMgr.AutomaticSolveOrder
+        buffer_ar = self.swEqnMgr.AutomaticRebuild
+        self.swEqnMgr.AutomaticSolveOrder = False
+        self.swEqnMgr.AutomaticRebuild = False
+
+        for i in range(self.nEquation):
+            # name, equation の取得
+            current_equation = self.swEqnMgr.Equation(i)
+            current_name = self._get_name_from_equation(current_equation)
+            # 対象なら処理
+            if current_name in list(user_param_dict.keys()):
+                new_equation = f'"{current_name}" = {user_param_dict[current_name]}'
+                self.swEqnMgr.Equation(i, new_equation)
+
+        # 式の計算
+        # noinspection PyStatementEffect
+        self.swEqnMgr.EvaluateAll  # always returns -1
+
+        # プロパティをもとに戻す
+        self.swEqnMgr.AutomaticSolveOrder = buffer_aso
+        self.swEqnMgr.AutomaticRebuild = buffer_ar
+
+        # 更新する（ここで失敗はしうる）
+        result = self.swModel.EditRebuild3  # モデル再構築
+        if not result:
+            raise ModelError('モデル再構築に失敗しました')
+
+    def _get_name_from_equation(self, equation:str):
+        pattern = r'^\s*"(.+?)"\s*$'
+        matched = re.match(pattern, equation.split('=')[0])
+        if matched:
+            return matched.group(1)
+        else:
+            return None

{pyfemtet-0.3.7 → pyfemtet-0.3.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyfemtet"
-version = "0.3.7"  # ignored by versioning plugin
+version = "0.3.9"  # ignored by versioning plugin
 description = "Design parameter optimization using Femtet."
 authors = ["kazuma.naito <kazuma.naito@murata.com>"]
 readme = "README.md"

pyfemtet-0.3.7/pyfemtet/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.7"

pyfemtet-0.3.7/pyfemtet/_old/_SW_Femtet.py

@@ -1,163 +0,0 @@
-import re
-import os
-from time import sleep
-
-import pandas as pd
-from win32com.client import DispatchEx, Dispatch
-
-from .core import Femtet
-
-# 定数の宣言
-swThisConfiguration = 1 # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
-swAllConfiguration = 2
-swSpecifyConfiguration = 3 # use with ConfigName argument
-swSaveAsCurrentVersion = 0 
-swSaveAsOptions_Copy = 2 # 
-swSaveAsOptions_Silent = 1 # https://help.solidworks.com/2021/english/api/swconst/solidworks.interop.swconst~solidworks.interop.swconst.swsaveasoptions_e.html
-swSaveWithReferencesOptions_None = 0 # https://help-solidworks-com.translate.goog/2023/english/api/swconst/SolidWorks.Interop.swconst~SolidWorks.Interop.swconst.swSaveWithReferencesOptions_e.html?_x_tr_sl=auto&_x_tr_tl=ja&_x_tr_hl=ja&_x_tr_pto=wapp
-swDocPART = 1 # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swDocumentTypes_e.html
-
-class SolidWorksAutomationError(Exception):
-    pass
-
-
-class SW_Femtet(Femtet):
-
-    def __init__(self, path_sldprt):
-        # 引数の処理
-        self.path_sldprt = os.path.abspath(path_sldprt)
-        
-        # SolidWorks を捕まえ、ファイルを開く
-        self.swApp = DispatchEx('SLDWORKS.Application')
-        self.swApp.Visible = True
-
-        # open model
-        self.swApp.OpenDoc(self.path_sldprt, swDocPART)
-        self.swModel = self.swApp.ActiveDoc
-        self.swEqnMgr = self.swModel.GetEquationMgr
-        self.nEquation = self.swEqnMgr.GetCount
-
-        # 引数の保存
-        super().__init__(self.path_sldprt)
-
-
-    def update(self, df:pd.DataFrame) ->None:
-        """Update_model_via_SW と run を実行します.
-
-        Parameters
-        ----------
-        df
-
-        Returns
-        -------
-
-        """
-
-        # df を dict に変換
-        user_param_dict = {}
-        for i, row in df.iterrows():
-            user_param_dict[row['name']] = row['value']
-
-        # 変数の存在チェック
-        self.check_parameter(user_param_dict)
-
-        # Femtet 解析モデルを更新
-        self.update_model_via_SW(user_param_dict)
-
-        # 解析を実行する
-        super().run()
-
-
-    def check_parameter(self, user_param_dict):
-        """与えられた変数セットが .sldprt ファイルに存在するか確認します."""
-        swEqnMgr = self.swModel.GetEquationMgr
-
-        # 指定された変数が SW に存在するかどうかをチェック
-        for user_param_name in user_param_dict.keys():
-            is_in_model = False
-            # global 変数に存在するかどうか
-            nEquation = swEqnMgr.GetCount
-            global_param_names = [self.get_name(swEqnMgr.Equation(i)) for i in range(nEquation) if swEqnMgr.GlobalVariable(i)]
-            is_in_model = is_in_model or (user_param_name in global_param_names)
-            # 寸法に存在するかどうか
-            swParam = self.swModel.Parameter(user_param_name)
-            is_in_model = is_in_model or (swParam is not None)
-            # is_in_model が False ならエラー
-            if not is_in_model:
-                raise Exception(f'no such parameter in SW:{user_param_name}')
-
-
-    def update_model_via_SW(self, user_param_dict):
-        """SW を使って parasolid を作り, Femtet 解析モデルを更新します."""
-        
-        # Femtet が参照している x_t パスを取得する
-        path_x_t = self.Femtet.Gaudi.LastXTPath
-        
-        # 先にそれを消しておく
-        if os.path.isfile(path_x_t):
-            os.remove(path_x_t)
-
-        # sldprt モデルの変数の更新
-        self.update_SW_parameter(user_param_dict)
-
-        # export parasolid
-        self.swModel.SaveAs(path_x_t)
-
-        # 30 秒待っても parasolid ができてなければエラー(COM なので)
-        timeout = 30
-        waiting = 0
-        while True:
-            sleep(1)
-            waiting += 1
-            if os.path.isfile(path_x_t):
-                break
-            else:
-                if waiting<timeout:
-                    continue
-                else:
-                    # from .core import ModelError
-                    # 再構築できていれば保存はできているはず
-                    raise SolidWorksAutomationError('parasolid 書き出しに失敗しました')
-
-        # Femtet モデルの更新 by ReExecute Femtet History
-        self.Femtet.Gaudi.ReExecute()
-        self.Femtet.Redraw()
-
-
-    def update_SW_parameter(self, user_param_dict):
-        # プロパティを退避
-        buffer_aso = self.swEqnMgr.AutomaticSolveOrder
-        buffer_ar = self.swEqnMgr.AutomaticRebuild
-        self.swEqnMgr.AutomaticSolveOrder = False
-        self.swEqnMgr.AutomaticRebuild = False
-        
-        from tqdm import trange
-        for i in trange(self.nEquation):
-            # name, equation の取得
-            current_equation = self.swEqnMgr.Equation(i)
-            current_name = self.get_name(current_equation)
-            # 対象なら処理
-            if current_name in list(user_param_dict.keys()):
-                new_equation = f'"{current_name}" = {user_param_dict[current_name]}'
-                self.swEqnMgr.Equation(i, new_equation)
-
-        # 式の計算
-        self.swEqnMgr.EvaluateAll # always returns -1
-        
-        # プロパティをもとに戻す
-        self.swEqnMgr.AutomaticSolveOrder = buffer_aso
-        self.swEqnMgr.AutomaticRebuild = buffer_ar
-
-        # 更新する（ここで失敗はしうる）
-        result = self.swModel.EditRebuild3 # モデル再構築
-        if result==False:
-            from .core import ModelError
-            raise ModelError('モデル再構築に失敗しました')
-        
-    def get_name(self, equation:str):
-        pattern = r'^\s*"(.+?)"\s*$'
-        matched = re.match(pattern, equation.split('=')[0])
-        if matched:
-            return matched.group(1)
-        else:
-            return None        

pyfemtet-0.3.7/pyfemtet/opt/__init__.py

@@ -1,2 +0,0 @@
-from .base import FEMOpt, OptunaOptimizer
-from .interface import FemtetInterface, NoFEM