pyfemtet 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

pyfemtet/FemtetPJTSample/_her_ex40_parametric.py

@@ -0,0 +1,148 @@
+"""Single-objective optimization: Resonant frequency of a circular patch antenna
+
+Using Femtet’s electromagnetic wave analysis solver,
+we explain an example of setting the resonant frequency
+of a circular patch antenna to a specific value.
+"""
+from time import sleep
+
+import numpy as np
+from scipy.signal import find_peaks
+from tqdm import tqdm
+from optuna.integration.botorch import BoTorchSampler
+
+from pyfemtet.opt import OptunaOptimizer, FEMOpt
+
+
+class SParameterCalculator:
+    """This class is for calculating S-parameters and resonance frequencies."""
+    
+    def __init__(self):
+        self.freq = []
+        self.S = []
+        self.interpolated_function = None
+        self.resonance_frequency = None
+        self.minimum_S = None
+
+    def get_result_from_Femtet(self, Femtet):
+        """Obtain the relationship between frequency and S-parameter from the Femtet analysis results."""
+
+        # Preparation
+        Femtet.OpenCurrentResult(True)
+        Gogh = Femtet.Gogh
+        
+        # Obtain the frequency and S(1,1) for each mode
+        mode = 0
+        freq_list = []
+        dB_S_list = []
+        for mode in tqdm(range(Gogh.Hertz.nMode), 'Obtaining frequency and S-parameter'):
+            # Femtet result screen mode settings
+            Gogh.Hertz.Mode = mode
+            sleep(0.01)
+            # Get frequency
+            freq = Gogh.Hertz.GetFreq().Real
+            # Get S-parameters
+            comp_S = Gogh.Hertz.GetSMatrix(0, 0)
+            norm = np.linalg.norm((comp_S.Real, comp_S.Imag))
+            dB_S = 20 * np.log10(norm)
+            # Get results
+            freq_list.append(freq)
+            dB_S_list.append(dB_S)
+        self.freq = freq_list
+        self.S = dB_S_list
+
+    def calc_resonance_frequency(self):
+        """Compute the frequency that gives the first peak for S-parameter."""
+        x = -np.array(self.S)
+        peaks, _ = find_peaks(x, height=None, threshold=None, distance=None, prominence=0.5, width=None, wlen=None, rel_height=0.5, plateau_size=None)
+        from pyfemtet.core import SolveError
+        if len(peaks) == 0:
+            raise SolveError('No peaks detected.')
+        self.resonance_frequency = self.freq[peaks[0]]
+        self.minimum_S = self.S[peaks[0]]
+
+    def get_resonance_frequency(self, Femtet):
+        """Calculate the resonant frequency.
+
+        Note:
+            The objective or constraint function
+            must take a Femtet as its first argument
+            and must return a single float.
+
+        Params:
+            Femtet: An instance for using Femtet macros. For more information, see "Femtet Macro Help / CFemtet Class".
+        
+        Returns:
+            float: A resonance frequency.
+        """
+        self.get_result_from_Femtet(Femtet)
+        self.calc_resonance_frequency()
+        f = self.resonance_frequency * 1e-9
+        return f  # GHz
+        
+
+def antenna_is_smaller_than_substrate(Femtet):
+    """Calculate the relationship between antenna size and board size.
+
+    This function is used to constrain the model
+    from breaking down while changing parameters.
+
+    Params:
+        Femtet: An instance for using Femtet macros.
+    
+    Returns:
+        float: Difference between the board size and antenna size. Must be equal to or grater than 1 mm.
+    """
+    ant_r = Femtet.GetVariableValue('ant_r')
+    Sx = Femtet.GetVariableValue('sx')
+    return Sx/2 - ant_r
+
+
+def port_is_inside_antenna(Femtet):
+    """Calculate the relationship between the feed port location and antenna size.
+
+    This function is used to constrain the model
+    from breaking down while changing parameters.
+
+    Params:
+        Femtet: An instance for using Femtet macros.
+    
+    Returns:
+        float: Difference between the antenna edge and the position of the feed port. Must be equal to or grater than 1 mm.
+    """
+    ant_r = Femtet.GetVariableValue('ant_r')
+    xf = Femtet.GetVariableValue('xf')
+    return ant_r - xf
+
+
+if __name__ == '__main__':
+    # Define the object for calculating S-parameters and resonance frequencies.
+    s = SParameterCalculator()
+
+    # Define mathematical optimization object.
+    opt = OptunaOptimizer(
+        sampler_class=BoTorchSampler,
+        sampler_kwargs=dict(
+            n_startup_trials=10,
+        )
+    )
+    
+    # Define FEMOpt object (This process integrates mathematical optimization and FEM.).
+    femopt = FEMOpt(opt=opt)
+    
+    # Add design variables (Use variable names set in Femtet) to the optimization problem.
+    femopt.add_parameter('ant_r', 10, 5, 20)
+    femopt.add_parameter('sx', 50, 40, 60)
+    femopt.add_parameter('xf', 5, 1, 20)
+
+    # Add constraint to the optimization problem.
+    femopt.add_constraint(antenna_is_smaller_than_substrate, 'board_antenna_clearance', lower_bound=1)
+    femopt.add_constraint(port_is_inside_antenna, 'antenna_port_clearance', lower_bound=1)
+
+    # Add objective to the optimization problem.
+    # The target frequency is 3 GHz.
+    femopt.add_objective(s.get_resonance_frequency, 'First_resonant_frequency(GHz)', direction=3.0)
+
+    femopt.set_random_seed(42)
+    femopt.optimize(n_trials=20)
+    femopt.terminate_all()

pyfemtet/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.2"
+__version__ = "0.4.4"

pyfemtet/opt/_femopt.py

@@ -81,6 +81,7 @@ class FEMOpt:
         self.monitor_process_future = None
         self.monitor_server_kwargs = dict()
         self.monitor_process_worker_name = None
+        self._is_error_exit = False
 
     # multiprocess 時に pickle できないオブジェクト参照の削除
     def __getstate__(self):
@@ -328,12 +329,27 @@ class FEMOpt:
             subprocess_indices = list(range(n_parallel))
             worker_addresses = list(self.client.nthreads().keys())
 
+            # worker が足りない場合はエラー
+            if n_parallel > len(worker_addresses):
+                raise RuntimeError(f'n_parallel({n_parallel}) > n_workers({len(worker_addresses)}). Worker 数が不足しています。')
+
+            # worker が多い場合は閉じる
+            if n_parallel < len(worker_addresses):
+                used_worker_addresses = worker_addresses[:n_parallel]  # 前から順番に選ぶ：CPU の早い / メモリの多い順に並べることが望ましい
+                unused_worker_addresses = worker_addresses[n_parallel:]
+                self.client.retire_workers(unused_worker_addresses, close_workers=True)
+                worker_addresses = used_worker_addresses
+
             # monitor worker の設定
             logger.info('Launching monitor server. This may take a few seconds.')
-            self.monitor_process_worker_name = datetime.datetime.now().strftime("Monitor-%Y%m%d-%H%M%S")
+            self.monitor_process_worker_name = datetime.datetime.now().strftime("Monitor%Y%m%d%H%M%S")
             current_n_workers = len(self.client.nthreads().keys())
-            from dask.distributed import Worker
-            Worker(scheduler_ip=self.client.scheduler.address, nthreads=1, name=self.monitor_process_worker_name)
+            from subprocess import Popen
+            import sys
+            Popen(
+                f'{sys.executable} -m dask worker {self.client.scheduler.address} --nthreads 1 --nworkers 1 --name {self.monitor_process_worker_name} --no-nanny',
+                shell=True
+            )
 
             # monitor 用 worker が増えるまで待つ
             self.client.wait_for_workers(n_workers=current_n_workers + 1)
@@ -357,12 +373,17 @@ class FEMOpt:
         # Femtet 特有の処理
         metadata = None
         if isinstance(self.fem, FemtetInterface):
+            # 結果 csv に記載する femprj に関する情報
             metadata = json.dumps(
                 dict(
                     femprj_path=self.fem.original_femprj_path,
                     model_name=self.fem.model_name
                 )
             )
+            # Femtet の parametric 設定を目的関数に用いるかどうか
+            if self.fem.use_parametric_as_objective:
+                from pyfemtet.opt.interface._femtet_parametric import add_parametric_results_as_objectives
+                add_parametric_results_as_objectives(self)
 
         # actor の設定
         self.status = OptimizationStatus(self.client)
@@ -389,7 +410,7 @@ class FEMOpt:
             # kwargs
             **self.monitor_server_kwargs,
             # kwargs of submit
-            workers=self.monitor_process_worker_name,  # if invalid arg,
+            workers=self.monitor_process_worker_name,
             allow_other_workers=False
         )
 
@@ -452,10 +473,13 @@ class FEMOpt:
         t_save_history.start()
 
         # 終了を待つ
-        self.client.gather(calc_futures)
+        local_opt_crashed = False
+        opt_crashed_list = self.client.gather(calc_futures)
         if not self.opt.is_cluster:  # 既存の fem を使っているならそれも待つ
             if t_main is not None:
                 t_main.join()
+                local_opt_crashed = self.opt._is_error_exit
+        opt_crashed_list.append(local_opt_crashed)
         self.status.set(OptimizationStatus.TERMINATED)
         end = time()
 
@@ -465,6 +489,13 @@ class FEMOpt:
         logger.info(f'計算が終了しました. 実行時間は {int(end - start)} 秒でした。ウィンドウを閉じると終了します.')
         logger.info(f'結果は{self.history.path}を確認してください.')
 
+        # ひとつでも crashed ならばフラグを立てる
+        if any(opt_crashed_list):
+            self._is_error_exit = True
+        
+        return self.history.local_data
+
+
     def terminate_all(self):
         """Try to terminate all launched processes.
 
@@ -476,7 +507,10 @@ class FEMOpt:
         sleep(1)
 
         # terminate monitor process
-        self.status.set(OptimizationStatus.TERMINATE_ALL)
+        if self._is_error_exit:
+            self.status.set(OptimizationStatus.CRASHED)
+        else:
+            self.status.set(OptimizationStatus.TERMINATE_ALL)
         logger.info(self.monitor_process_future.result())
         sleep(1)
 
@@ -514,22 +548,20 @@ class FEMOpt:
         else:
             logger.warn('Monitor process worker not found.')
 
-        # close scheduler, other workers(, cluster)
-        self.client.close()
-        while self.client.scheduler is not None:
-            sleep(1)
-        logger.info('Terminate client.')
-
         # close FEM (if specified to quit when deconstruct)
         del self.fem
         logger.info('Terminate FEM.')
+        sleep(1)
 
-        # terminate dask relative processes.
-        if not self.opt.is_cluster:
-            self.client.shutdown()
-            logger.info('Terminate all relative processes.')
+        # close scheduler, other workers(, cluster)
+        self.client.shutdown()
+        logger.info('Terminate all relative processes.')
         sleep(3)
 
+        # if optimization was crashed, raise Exception
+        if self._is_error_exit:
+            raise RuntimeError('At least 1 of optimization processes have been crashed. See console log.')
+
 
 def _start_monitor_server(
         history,

pyfemtet/opt/_femopt_core.py

@@ -7,6 +7,7 @@ import datetime
 import inspect
 import ast
 import csv
+import ctypes
 
 # 3rd-party
 import numpy as np
@@ -197,9 +198,12 @@ class Function:
 
         # serializable でない COM 定数を parallelize するため
         # COM 定数を一度 _Scapegoat 型のオブジェクトにする
-        for varname in fun.__globals__:
-            if isinstance(fun.__globals__[varname], Constants):
-                fun.__globals__[varname] = _Scapegoat()
+        # ParametricIF で使う dll 関数は _FuncPtr 型であって __globals__ を持たないが、
+        # これは絶対に constants を持たないので単に無視すればよい。
+        if not isinstance(fun, ctypes._CFuncPtr):
+            for varname in fun.__globals__:
+                if isinstance(fun.__globals__[varname], Constants):
+                    fun.__globals__[varname] = _Scapegoat()
 
         self.fun = fun
         self.name = name
@@ -224,10 +228,11 @@ class Function:
     def _restore_constants(self):
         """Helper function for parallelize Femtet."""
         fun = self.fun
-        for varname in fun.__globals__:
-            if isinstance(fun.__globals__[varname], _Scapegoat):
-                if not fun.__globals__[varname]._ignore_when_restore_constants:
-                    fun.__globals__[varname] = constants
+        if not isinstance(fun, ctypes._CFuncPtr):
+            for varname in fun.__globals__:
+                if isinstance(fun.__globals__[varname], _Scapegoat):
+                    if not fun.__globals__[varname]._ignore_when_restore_constants:
+                        fun.__globals__[varname] = constants
 
 
 class Objective(Function):
@@ -691,6 +696,7 @@ class OptimizationStatus:
     RUNNING = 30
     INTERRUPTING = 40
     TERMINATED = 50
+    CRASHED = 55
     TERMINATE_ALL = 60
 
     def __init__(self, client, name='entire'):
@@ -712,6 +718,7 @@ class OptimizationStatus:
         if status_const == cls.INTERRUPTING: return 'Interrupting'
         if status_const == cls.TERMINATED: return 'Terminated'
         if status_const == cls.TERMINATE_ALL: return 'Terminate_all'
+        if status_const == cls.CRASHED: return 'Crashed'
 
     def set(self, status_const):
         """Set optimization status."""

pyfemtet/opt/femprj_sample/cad_ex01_NX.py

@@ -0,0 +1,132 @@
+"""External CAD (NX) Integration
+
+Using Femtet's stress analysis solver and Siemens' CAD software NX,
+design a lightweight and high-strength H-shaped beam.
+
+As a preliminary step, please perform the following procedures:
+- Install NX
+- Create a C:\temp folder
+    - Note: NX will save a .x_t file in this folder.
+- Place the following files in the same folder:
+    - cad_ex01_NX.py (this file)
+    - cad_ex01_NX.prt
+    - cad_ex01_NX.femprj
+"""
+
+import os
+
+from win32com.client import constants
+
+from pyfemtet.opt import FEMOpt
+from pyfemtet.opt.interface import FemtetWithNXInterface
+from pyfemtet.core import ModelError
+
+
+here, me = os.path.split(__file__)
+os.chdir(here)
+
+
+def von_mises(Femtet):
+    """Obtain the maximum von Mises stress of the model.
+
+    Note:
+        The objective or constraint function should take Femtet
+        as its first argument and return a float as the output.
+
+    Warning:
+        CAD integration may assign boundary conditions to unintended locations.
+
+        In this example, if the boundary conditions are assigned as intended,
+        the maximum z displacement is always negative.
+        If the maximum displacement is not negative, it is assumed that
+        boundary condition assignment has failed.
+        Then this function raises a ModelError.
+
+        If a ModelError, MeshError, or SolveError occurs during optimization,
+        the optimization process considers the attempt a failure and skips to
+        the next trial.
+    """
+
+    # Simple check for the correctness of boundary conditions.
+    dx, dy, dz = Femtet.Gogh.Galileo.GetMaxDisplacement_py()
+    if dz >= 0:
+        raise ModelError('Assigning unintended boundary conditions.')
+
+    # Von Mises stress calculation.
+    Gogh = Femtet.Gogh
+    Gogh.Galileo.Potential = constants.GALILEO_VON_MISES_C
+    succeed, (x, y, z), mises = Gogh.Galileo.GetMAXPotentialPoint_py(constants.CMPX_REAL_C)
+
+    return mises
+
+
+def mass(Femtet):
+    """Obtain model mass."""
+    return Femtet.Gogh.Galileo.GetMass('H_beam')
+
+
+def C_minus_B(Femtet, opt):
+    """Calculate the difference between C and B dimensions.
+
+    Another example uses the following snippet to access design variables:
+
+        A = Femtet.GetVariableValue('A')
+    
+    However, when performing CAD integration, this method does not work
+    because the variables are not set in the .femprj file.
+
+    In CAD integration, design variables are obtained in the following way.
+
+        # How to obtain a dictionary with the variable names of parameters
+        # added by add_parameter() as keys.
+        params: dict = opt.get_parameter()
+        A = params['A']
+
+    Or
+
+        # How to obtain an array of values of parameters added in the order
+        # by add_parameter().
+        values: np.ndarray = opt.get_parameter('values')
+        A, B, C = values
+
+    Objective functions and constraint functions can take arbitrary variables
+    after the first argument.
+    The FEMOpt member variable `opt` has a method called get_parameter().
+    This method allows you to retrieve design variables added by add_parameter().
+    By taking `opt` as the second argument, you can execute get_parameter()
+    within the objective or constraint function to retrieve design variables.
+    """
+    A, B, C = opt.get_parameter('values')
+    return C - B
+
+
+if __name__ == '__main__':
+
+    # Initialize NX-Femtet integration object.
+    # At this point, Python is connected to the Femtet.
+    fem = FemtetWithNXInterface(
+        prt_path='cad_ex01_NX.prt',
+        open_result_with_gui=False,  # To calculate von Mises stress, set this argument to False. See Femtet Macro Help.
+    )
+
+    # Initialize the FEMOpt object.
+    # (establish connection between the optimization problem and Femtet)
+    femopt = FEMOpt(fem=fem)
+
+    # Add design variables to the optimization problem.
+    # (Specify the variables registered in the femprj file.)
+    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)
+
+    # Add the constraint function to the optimization problem.
+    femopt.add_constraint(C_minus_B, 'C>B', lower_bound=1, args=femopt.opt)
+
+    # Add the objective function to the optimization problem.
+    femopt.add_objective(von_mises, name='von Mises (Pa)')
+    femopt.add_objective(mass, name='mass (kg)')
+
+    # Run optimization.
+    femopt.set_random_seed(42)
+    femopt.optimize(n_trials=20)
+    femopt.terminate_all()

pyfemtet/opt/femprj_sample/cad_ex01_SW.py

@@ -0,0 +1,132 @@
+"""External CAD (SOLIDWORKS) Integration
+
+Using Femtet's stress analysis solver and Dassault Systemes' CAD software SOLIDWORKS,
+design a lightweight and high-strength H-shaped beam.
+
+As a preliminary step, please perform the following procedures:
+- Install SOLIDWORKS
+- Create a C:\temp folder
+    - Note: SOLIDWORKS will save a .x_t file in this folder.
+- Place the following files in the same folder:
+    - cad_ex01_SW.py (this file)
+    - cad_ex01_SW.SLDPRT
+    - cad_ex01_SW.femprj
+"""
+
+import os
+
+from win32com.client import constants
+
+from pyfemtet.opt import FEMOpt
+from pyfemtet.opt.interface import FemtetWithSolidworksInterface
+from pyfemtet.core import ModelError
+
+
+here, me = os.path.split(__file__)
+os.chdir(here)
+
+
+def von_mises(Femtet):
+    """Obtain the maximum von Mises stress of the model.
+
+    Note:
+        The objective or constraint function should take Femtet
+        as its first argument and return a float as the output.
+
+    Warning:
+        CAD integration may assign boundary conditions to unintended locations.
+
+        In this example, if the boundary conditions are assigned as intended,
+        the maximum z displacement is always negative.
+        If the maximum displacement is not negative, it is assumed that
+        boundary condition assignment has failed.
+        Then this function raises a ModelError.
+
+        If a ModelError, MeshError, or SolveError occurs during optimization,
+        the optimization process considers the attempt a failure and skips to
+        the next trial.
+    """
+
+    # Simple check for the correctness of boundary conditions.
+    dx, dy, dz = Femtet.Gogh.Galileo.GetMaxDisplacement_py()
+    if dz >= 0:
+        raise ModelError('Assigning unintended boundary conditions.')
+
+    # Von Mises stress calculation.
+    Gogh = Femtet.Gogh
+    Gogh.Galileo.Potential = constants.GALILEO_VON_MISES_C
+    succeed, (x, y, z), mises = Gogh.Galileo.GetMAXPotentialPoint_py(constants.CMPX_REAL_C)
+
+    return mises
+
+
+def mass(Femtet):
+    """Obtain model mass."""
+    return Femtet.Gogh.Galileo.GetMass('H_beam')
+
+
+def C_minus_B(Femtet, opt):
+    """Calculate the difference between C and B dimensions.
+
+    Another example uses the following snippet to access design variables:
+
+        A = Femtet.GetVariableValue('A')
+    
+    However, when performing CAD integration, this method does not work
+    because the variables are not set in the .femprj file.
+
+    In CAD integration, design variables are obtained in the following way.
+
+        # How to obtain a dictionary with the variable names of parameters
+        # added by add_parameter() as keys.
+        params: dict = opt.get_parameter()
+        A = params['A']
+
+    Or
+
+        # How to obtain an array of values of parameters added in the order
+        # by add_parameter().
+        values: np.ndarray = opt.get_parameter('values')
+        A, B, C = values
+
+    Objective functions and constraint functions can take arbitrary variables
+    after the first argument.
+    The FEMOpt member variable `opt` has a method called get_parameter().
+    This method allows you to retrieve design variables added by add_parameter().
+    By taking `opt` as the second argument, you can execute get_parameter()
+    within the objective or constraint function to retrieve design variables.
+    """
+    A, B, C = opt.get_parameter('values')
+    return C - B
+
+
+if __name__ == '__main__':
+
+    # Initialize NX-Femtet integration object.
+    # At this point, Python is connected to the Femtet.
+    fem = FemtetWithSolidworksInterface(
+        sldprt_path='cad_ex01_SW.SLDPRT',
+        open_result_with_gui=False,  # To calculate von Mises stress, set this argument to False. See Femtet Macro Help.
+    )
+
+    # Initialize the FEMOpt object.
+    # (establish connection between the optimization problem and Femtet)
+    femopt = FEMOpt(fem=fem)
+
+    # Add design variables to the optimization problem.
+    # (Specify the variables registered in the femprj file.)
+    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)
+
+    # Add the constraint function to the optimization problem.
+    femopt.add_constraint(C_minus_B, 'C>B', lower_bound=1, args=femopt.opt)
+
+    # Add the objective function to the optimization problem.
+    femopt.add_objective(von_mises, name='von Mises (Pa)')
+    femopt.add_objective(mass, name='mass (kg)')
+
+    # Run optimization.
+    femopt.set_random_seed(42)
+    femopt.optimize(n_trials=20)
+    femopt.terminate_all()