External CAD (Solidworks) Integration

PyFemtet allows parametric optimization even for analysis models created with external CAD (Solidworks) and imported into Femtet.

An example will be explained using an H-shaped steel that was parametrically modeled in an external CAD (Solidworks) and analyzed using Femtet’s stress analysis solver to minimize volume while minimizing displacement.

Note

Other than the sample code and execution results, the items are similar as in External CAD (NX) Integration.

Sample File

Note

Place the sample model and sample project in the same folder, keep the project open in Femtet, and double-click on sample code to execute.

Details as a FEM Problem

Appearance of the Model (and Analysis Conditions)

• fix … Fully Fixed

• load … Load in the -Z direction (1N)

• mirror … Symmetrical to the XZ plane

Design Variables

Appearance of the Model Section (and Design Variables)

Variable Name	Description
A	Web Tickness
B	Flange Tickness
C	Flange Bending

Sample Code

cad_ex01_SW.py

"""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.opt.exceptions 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 SW-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 .SLDPRT 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(fun=C_minus_B, name='C>B', lower_bound=1, args=(femopt.opt,))

    # Add the objective function to the optimization problem.
    femopt.add_objective(fun=von_mises, name='von Mises (Pa)')
    femopt.add_objective(fun=mass, name='mass (kg)')

    # Run optimization.
    femopt.set_random_seed(42)
    femopt.optimize(n_trials=20)

Execution Result of the Sample Code

Execution result of Sldworks_ex01.py. The horizontal axis is von Mises stress, and the vertical axis is mass.

After 20 trials, a Pareto set of von Mises stress and mass is obtained.

Note

Results may vary slightly depending on the versions of Femtet, PyFemtet, and the optimization engine it depends on.