PyFemtet 0.3.6__tar.gz → 0.3.8__tar.gz

{pyfemtet-0.3.6 → pyfemtet-0.3.8}/PKG-INFO

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

{pyfemtet-0.3.6 → pyfemtet-0.3.8}/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.6 → pyfemtet-0.3.8}/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.6 → pyfemtet-0.3.8}/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.8/pyfemtet/__init__.py

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

{pyfemtet-0.3.6 → pyfemtet-0.3.8}/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.8/pyfemtet/opt/__init__.py

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

{pyfemtet-0.3.6 → pyfemtet-0.3.8}/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)
 
@@ -217,7 +214,7 @@ class Function:
         # Femtet 特有の処理
         if isinstance(fem, FemtetInterface):
             args = (fem.Femtet, *args)
-        return self.fun(*args, **self.kwargs)
+        return float(self.fun(*args, **self.kwargs))
 
     def _restore_constants(self):
         """Helper function for parallelize Femtet."""
@@ -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.
 
@@ -280,7 +282,7 @@ class Objective(Function):
 
         ret = symlog(ret)
 
-        return ret
+        return float(ret)
 
 
 class Constraint(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(str(type(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().**
 
         """
 
@@ -1296,7 +1321,8 @@ class FEMOpt:
         if not self.opt.is_cluster:
             subprocess_indices = subprocess_indices[1:]
         worker_addresses = list(self.client.nthreads().keys())
-        assert max(subprocess_indices) <= len(worker_addresses)-1, f'コア数{len(worker_addresses)}は不足しています。'
+        if len(subprocess_indices)>0:
+            assert max(subprocess_indices) <= len(worker_addresses)-1, f'コア数{len(worker_addresses)}は不足しています。'
         worker_addresses = worker_addresses[:len(range(n_parallel))]  # TODO: ノードごとに適度に振り分ける
         if not self.opt.is_cluster:
             worker_addresses[0] = 'Main'
@@ -1322,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,
@@ -1344,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()
@@ -1406,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)
@@ -1452,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.6 → pyfemtet-0.3.8}/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,29 +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'.
+            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()
@@ -151,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:
@@ -160,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
 
@@ -170,7 +156,7 @@ class FemtetInterface(FEMInterface):
         # 接続した Femtet の種類に応じて del 時に quit するかどうか決める
         self.quit_when_destruct = self.connected_method == 'new'
 
-        # restore するための情報保管
+        # subprocess で restore するための情報保管
         # パスなどは connect_and_open_femtet での処理結果を反映し
         # メインで開いた解析モデルが確実に開かれるようにする
         super().__init__(
@@ -201,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'
 
@@ -217,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.
 
         """
 
@@ -398,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:
@@ -596,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,
@@ -609,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')
@@ -633,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()
 
@@ -679,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)
@@ -711,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.6 → pyfemtet-0.3.8}/pyproject.toml

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

pyfemtet-0.3.6/pyfemtet/__init__.py

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

pyfemtet-0.3.6/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.6/pyfemtet/opt/__init__.py

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