Aerostruct Problem

The Aerostruct problem provides an interface for generating static aerostructural wing datasets using a coupled high-fidelity analysis. Specifically, this problem couples a computational fluid dynamics (CFD) solver with a finite element (FE) solver to perform static aerostructural analysis. The Aerostruct problem currently uses ADflow as the CFD solver, TACS as the FE solver, and OpenVSP for wing shape parameteriation. Users can parameterize wing planform parameters, wing airfoil cross-section, operating conditions, and evaluate the resulting configurations without manually setting up the geometry paramerization, coupled analysis, and post-processing workflow. Additional CFD solvers, such as OpenFOAM and SU2, may be supported in future releases. The following sections describe the dependencies, computational workflow, and how to generate aerostructural datasets with the Aerostruct problem.

Dependencies

The Aerostruct problem requires several additional packages that must be installed before using this problem. The required packages and their corresponding versions are listed below.

Package

Version

Comments

mpi4py

3.1.6

Used for parallel processing during mesh deformation, CFD, and FE solver execution

psutil

-

Used for monitoring child processes launched for coupled analysis

mdolab-baseclasses

>= 1.8.4

Provides AeroProblem for defining flow conditions

openvsp

-

Handles wing shape paramerization

pygeo

>= 1.17.0

Provides an interface for handling wing shape parameterization through OpenVSP

idwarp

>= 2.6.2

Used for morphing volume mesh based on given shape parameters and during coupled analysis

adflow

2.11.0

Used as the CFD solver for aerodynamic simulations

tacs

3.7.2

Used as the FE solver for structural simulations

funtofem

0.3.7

Used for transfering loads and displacement between CFD/FE solvers

mphys

1.3.0

Used for setting up coupled aerostructural analysis with CFD and FE solver

pyvista

-

Used for reading, processing, and writing surface and volume field data

h5py

-

Used for creating and storing field results in HDF5 format

Make sure that all required packages are installed with compatible versions before using the Aerostruct problem.

Workflow

The Aerostruct problem accepts a set of samples, where each sample contains parameter values. This set may contain a single sample or multiple samples. For each sample \(x_i\) in the sample set, the Aerostruct problem performs the sequence of operations described below:

  1. Wing shape parameterization: Geometry parameters are used to define the wing planform shape and airfoil cross-section through OpenVSP and pyGeo. Based on the geometry parameters, baseline CFD surface mesh coordinates and baseline wingbox FE mesh are deformed.

  2. Volume Mesh deformation: The baseline CFD volume mesh is deformed based on the updated surface mesh coordinates using idwarp.

  3. Coupled analysis: A coupled analysis is then performed using the updated CFD volume mesh and the wingbox FE mesh, along with flow parameters and load factor.

  4. Output extraction: Scalar and field quantities from the converged solver results are extracted and stored in a folder.

When multiple samples are provided, the workflow is evaluated for each sample, and the resulting outputs are stored separately for each sample. This allows the Aerostruct problem to provide a consistent interface for generating datasets without requiring users to manually manage geometry processing, mesh deformation, coupled solver execution, or output handling.

The complete workflow is illustrated in the XDSM diagram below.

aerstruct problem xdsm

The stacked rectangles representing various blocks such as shape paramerization, volume mesh deformation, CFD, and FE analysis indicate that these operations use multiple processors through MPI. The Aerostruct problem therefore abstracts geometry processing, mesh deformation, coupled-solver execution, and output handling required for each sample.

Basic usage

Setting up Aerostruct problem and generating dataset is very similar to Wing problem. It is recommended that you go through Wing problem basic usage section before moving forward. To use the Aerostruct problem, you will require following items:

  1. Baseline volume CFD mesh in CGNS format

  2. Baseline wingbox FE mesh in BDF format

  3. OpenVSP model for the baseline wing (only required if wing shape will be parametrized)

Make sure that the CFD and FE mesh work with corresponding solvers before using it with Aerostruct problem. The requirements for the OpenVSP file are provided here. The files used in the example demonstrated below are available in the examples/wing_aerostruct_vsp directory.

Defining flow and wing geometry parameters

The flow and wing geometry parameters are defined in a similar manner as it is done for Wing problem:

Note

Load factor can be added as a parameter while initializing the Aerostruct problem

Following code snippet illustrates how to define flow and wing geometry parameters:

import numpy as np
from baseclasses import AeroProblem
from blackbox.wing_problem import WingVSP

# create aero problem object
aero_problem = AeroProblem(name="wing", alpha=2.5, mach=0.85, altitude=10000, areaRef=45.5, chordRef=3.56)

# add parameters
aero_problem.addDV(key="mach", lower=0.75, upper=0.8)
aero_problem.addDV(key="alpha", lower=1, upper=4)
aero_problem.addDV(key="altitude", lower=8000, upper=12000)

# create wing vsp object
wing_vsp = WingVSP("wing.vsp3")

# add wing planform variables
wing_vsp.add_shape_parameter(name="Dihedral", lower=0.0, upper=5.0, sections=[1])
wing_vsp.add_shape_parameter(name="Sweep", lower=25.0, upper=35.0, sections=[1])
wing_vsp.add_shape_parameter(name="Span", lower=12.0, upper=16.0, sections=[1])
wing_vsp.add_shape_parameter(name="Twist", lower=-5.0, upper=0.0, sections=[1])

# cst coefficients
upper_cst_coeff = np.array([0.12344046, 0.14809657, 0.14858145, 0.2168004,  0.17607825, 0.21018404])
lower_cst_coeff = np.array([-0.13198943, -0.11895939, -0.22056435, -0.12743513, -0.08232715, 0.05055414])

# add airfoil upper surface cst coefficients
wing_vsp.add_airfoil_cst_parameters(
    "upper", 
    upper_cst_coeff - np.sign(upper_cst_coeff)*0.3*upper_cst_coeff,
    upper_cst_coeff + np.sign(upper_cst_coeff)*0.3*upper_cst_coeff,
    sections=[0,1]
)

# add airfoil lower surface cst coefficients
wing_vsp.add_airfoil_cst_parameters(
    "lower", 
    lower_cst_coeff - np.sign(lower_cst_coeff)*0.3*lower_cst_coeff,
    lower_cst_coeff + np.sign(lower_cst_coeff)*0.3*lower_cst_coeff,
    sections=[0,1]
)

Initializing the problem

Next step is to initialize the WingAeroStructOptions class by setting appropraite options. There are several options that can be provided while creating the options class, refer to complete options list for all available options. Most of the options are optional, except the aero_mesh_file, aero_solver_options, aero_problem, and struct_mesh_file are mandatory options. The initialized options object is used to create the main WingADFflowVSP problem object. Following code snippet illustrates how to initialize the WingAeroStructVSP problem class:

from blackbox.aerostruct_problem import WingAeroStructOptions, WingAeroStructVSP

aero_solver_options = {
    # Common Parameters
    "monitorvariables": ["cl", "cd", "yplus"],
    # Physics Parameters
    "equationType": "RANS",
    "smoother": "DADI",
    "MGCycle": "sg",
    "nsubiterturb": 10,
    "nCycles": 7000,
    "liftIndex": 3,
    # ANK Solver Parameters
    "useANKSolver": True,
    "ANKSubspaceSize": 400,
    "ANKASMOverlap": 3,
    "ANKPCILUFill": 4,
    "ANKJacobianLag": 5,
    "ANKOuterPreconIts": 3,
    "ANKInnerPreconIts": 3,
    # Termination Criteria
    "L2Convergence": 1e-8
}

options = WingAeroStructOptions(
    wing_vsp=wing_vsp,
    aero_mesh_file="wing_vol_mesh.cgns",
    aero_solver_options=aero_solver_options,
    aero_problem=aero_problem,
    struct_mesh_file="wingbox.bdf",
    load_factor_parameter=True,
    load_factor_lb=0.8,
    load_factor_ub=1.2,
    write_surface_output=True,
    write_volume_output=True,
    num_processors=10,
    write_vsp_file=True,
    write_stl_file=True,
    write_slice_file=True,
    write_lift_distribution=True
)

wing_aerostruct = WingAeroStructVSP(options=options)

Note that the load factor is added as a parameter by setting load_factor_parameter to True. You can also set its lower and upper bound using load_factor_lb and load_factor_ub, respectively.

Evaluating samples

After defining the problem, evaluating samples is straightforward. Following code snippet illustrates how to evaluate a set of samples:

from pyDOE3 import lhs

# generate sampling plan for evaluation
samples = lhs(n=wing_aerostruct.bounds[0].shape[0], samples=10, criterion="cm", iterations=100)
samples = wing_aerostruct.bounds[0] + (wing_aerostruct.bounds[1] - wing_aerostruct.bounds[0]) * samples

wing_aerostruct(samples, return_results=False)

Firstly, 10 samples are generated using a Latin hypercube sampling (LHS) method within a unit hypercube. You can use any sampling method of your choice to generate samples. These samples are then scaled to appropriate bounds for the problem. The bounds can be accessed through the bounds property of the initialized problem object. This property is a tuple containing two 1D numpy arrays: first array contains the lower bounds and the second array contains the upper bounds.

In the code snippet above, samples is a numpy array with shape (10, 20). The 10 represents the number of samples, while 20 represents the number of parameters. Each row in samples array corresponds to a different sample, i.e., a different set of parameter values. The order of the values in each row is determined by the order in which the parameters were added to the problem.

For example, in this case, the first three entries correspond to flow parameters. The next four entries are for wing planform parameters. The next twelve entries correspond to cross-section airfoil CST parameters, and the remaining entry corresponds to load factor. Note that, in aerostruct problem, flow parameters will always preceed shape parameters, while the load factor will always be the last parameter, if added as a parameter.

The initialized Aerostruct problem object (wing_aerostruct in this case) can then be called with the samples to be evaluated. The __call__ method accepts two arguments:

  • x (numpy array): an array of shape (N,D) or (D,) representing the samples to be evaluated. Here, N denotes the number of samples and D denotes the number of parameters

  • return_results (bool): a flag indicating whether the results should be returned by the function (default = False). Set this to True when the results are needed directly in Python, such as during active learning. When return_results is False, the requested outputs from each simulation are stored in the corresponding sample directory.

Once the dataset generation process starts, a directory with the name specified by the directory option is created. All generated data is stored within this directory. The directory structure is organized as follows:

  • The main directory contains a description.txt file that provides information about the generated dataset, including the parameters and their bounds.

  • A separate subdirectory is created for each evaluated sample. The subdirectories are numbered sequentially starting from 1 (i.e., 1, 2, 3, and so on), with each number corresponding to the row of the samples array that was evaluated. For example, the directory 1 contains the results for samples[0], 2 contains the results for samples[1], and so on.

  • Each sample directory contains the files generated during the simulation. Depending on the options provided during initializating WingAeroStructOptions class, the following files may be present:

    • log.txt: a log file containing messages generated during mesh deformation and solver execution

    • parameters.json: a JSON file containing the parameter values used for the sample

    • scalar_outputs.json: a JSON file containing the scalar outputs specified by the scalar_outputs option.

    • surface_solution.cgns: the surface solution written by the CFD solver. This file is stored only when write_surface_output is set to True

    • volume_solution.cgns: the volume solution written by the CFD solver. This file is stored only when write_volume_output is set to True

    • structural_solution.f5: the structural solution written by the FE solver. This file is stored only when write_structural_output is set to True

    • surface_outputs.hdf5: field data extracted from the surface solution and stored in an HDF5 file. This file is stored only when write_surface_output is set to True. It will contain entities provided in the surface_outputs option

    • volume_outputs.hdf5: field data extracted from the volume solution and stored in an HDF5 file. This file is stored only when write_volume_output is set to True. It will contain entities provided in the volume_outputs option

    • structural_solution.vtu: structural data extracted from the f5 file and stored in vtu format. This file is stored only when write_structural_output is set to True.

    • lift_distribution.dat: a dat file containing lift distribution along the wing span, this file is written only when write_lift_distribution is set to True

    • slices.dat: a dat file containing flow quantities along wing cross-section at different locations (from root till tip), this file is stored only when write_slice_file is set to True

    • updated_model.vsp3: an OpenVSP file containing updated wing model, this file is stored only when write_vsp_file is set to True

    • updated_model.stl: a stl file describing the updated wing model, this file is stored only when write_stl_file is set to True

Options

Following is the exhaustive list of options that can be set by the user for the AeroStruct problem:

aero_mesh_file: str

Path to the cgns volume mesh file for the wing geometry

aero_solver_options: dict

Dictionary of ADflow solver options passed directly to the solver

aero_problem: AeroProblem

AeroProblem instance defining flow conditions for the ADflow solver, this field is excluded from serialization

struct_mesh_file: str

Path to the wingbox structural mesh BDF file for the FE analysis

wing_vsp: WingVSP = None

Instance of WingVSP class defining various shape parameters. This argument is mandatory for setting shape parameters

element_callback_function: Callable = None

Callable that is used by TACS to setup elements for structural sizing

directory: str = 'output'

Directory where all simulation outputs will be written

num_processors: int = 4

Number of processors to use for the ADflow simulation

scalar_outputs: list = ['cl', 'clp', 'clv', 'cd', 'cdp', 'cdv', 'cmx', 'cmy', 'cmz']

List of scalar output identifiers to be written during the simulation, the provided list must contain atleast one valid identifier

surface_outputs: list = ['rho', 'p', 'temp', 'cp', 'cf', 'cfx', 'cfy', 'cfz', 'yplus']

List of surface output identifiers to be written during the simulation, the provided list must contain atleast one valid identifier

volume_outputs: list = ['cp', 'mach']

List of volume output identifiers to be written during the simulation, the provided list must contain atleast one valid identifier

load_factor_parameter: bool = False

Flag to indicate whether load factor will be varied or not. By default, a standard 1g load factor is applied. If True, then load factor is alos considered as a parameter with load_factor_lb and load_factor_ub as lower and upper bound, respectively.

load_factor_lb: float = 0.8

Lower bound for the load factor parameter

load_factor_ub: float = 1.2

Upper bound for the load factor parameter

write_surface_output: bool = True

If True, write surface output from adflow in cgns format. A ready-to-use HDF5 file containing surface data extracted from cgns file is also written

write_volume_output: bool = True

If True, write volume output from adflow in cgns format. A ready-to-use HDF5 file containing volume data extracted from cgns file is also written

write_structural_output: bool = True

If True, write raw structural output from TACS. A vtu file is also written that contains all the structural output from TACS

write_vsp_file: bool = False

If True, write the updated VSP model in vsp3 file. This option will only work when shape variables are added

write_stl_file: bool = False

If True, write the updated VSP model in a stl file. This option will only work when shape variables are added

write_lift_distribution: bool = False

If True, add a lift distribution along the wing span and write the distribution file after analysis

num_segments: int = 200

Number of points to use along the wing span while writing lift distribution file, only relevant when write_lift_distribution is set to True

write_slice_file: bool = False

If True, add slices along the wing span and write the slice file after analysis

slice_location: list = [0.05, 0.2, 0.4, 0.6, 0.8, 0.95]

List describing relative slice location along the wing span, only relevant when write_slice_file is set to True