From 2662803688565ef68579da44d5e0ea6a679b369e Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Tue, 20 May 2025 15:25:16 -0400
Subject: [PATCH 01/30] truss-braced structure model

---
 openaerostruct/structures/disp.py             |   5 +-
 openaerostruct/structures/fem.py              | 128 ++++---
 openaerostruct/structures/fem_truss_braced.py | 339 ++++++++++++++++++
 .../structures/spatial_beam_states.py         |  64 +++-
 4 files changed, 474 insertions(+), 62 deletions(-)
 create mode 100644 openaerostruct/structures/fem_truss_braced.py

diff --git a/openaerostruct/structures/disp.py b/openaerostruct/structures/disp.py
index 4a5a59b89..8d5f1e85f 100644
--- a/openaerostruct/structures/disp.py
+++ b/openaerostruct/structures/disp.py
@@ -9,14 +9,15 @@ class Disp(om.ExplicitComponent):
     a 2D array so we can more easily use the results.
 
     The solution to the linear system has meaingless entires due to the
-    constraints on the FEM model. The displacements from this portion of
+    boundary conditions on the FEM model. The "displacements" from this portion of
     the linear system are not needed, so we select only the relevant
     portion of the displacements for further calculations.
 
     Parameters
     ----------
     disp_aug[6*(ny+1)] : numpy array
-        Augmented displacement array. Obtained by solving the system
+        Augmented displacement array with additional 6 Lagrange multipliers 
+        for clamp boundary conditions at the end. Obtained by solving the system
         K * disp_aug = forces, where forces is a flattened version of loads.
 
     Returns
diff --git a/openaerostruct/structures/fem.py b/openaerostruct/structures/fem.py
index ef962e33c..4c6492875 100644
--- a/openaerostruct/structures/fem.py
+++ b/openaerostruct/structures/fem.py
@@ -7,6 +7,74 @@
 import openmdao.api as om
 
 
+def get_drdu_sparsity_pattern(ny, vec_size, symmetry):
+    """
+    return sparsity pattern of partials of residuals w.r.t. displacements = stiffness matrix
+    """
+    base_row = np.repeat(0, 6)
+    base_col = np.arange(6)
+
+    # Upper diagonal blocks
+    rows1 = np.tile(base_row, 6 * (ny - 1)) + np.repeat(np.arange(6 * (ny - 1)), 6)
+    col = np.tile(base_col + 6, 6)
+    cols1 = np.tile(col, ny - 1) + np.repeat(6 * np.arange(ny - 1), 36)
+
+    # Lower diagonal blocks
+    rows2 = np.tile(base_row + 6, 6 * (ny - 1)) + np.repeat(np.arange(6 * (ny - 1)), 6)
+    col = np.tile(base_col, 6)
+    cols2 = np.tile(col, ny - 1) + np.repeat(6 * np.arange(ny - 1), 36)
+
+    # Main diagonal blocks, root
+    rows3 = np.tile(base_row, 6) + np.repeat(np.arange(6), 6)
+    cols3 = np.tile(base_col, 6)
+
+    # Main diagonal blocks, tip
+    rows4 = np.tile(base_row + (ny - 1) * 6, 6) + np.repeat(np.arange(6), 6)
+    cols4 = np.tile(base_col + (ny - 1) * 6, 6)
+
+    # Main diagonal blocks, interior
+    rows5 = np.tile(base_row + 6, 6 * (ny - 2)) + np.repeat(np.arange(6 * (ny - 2)), 6)
+    col = np.tile(base_col + 6, 6)
+    cols5 = np.tile(col, ny - 2) + np.repeat(6 * np.arange(ny - 2), 36)
+
+    # Find constrained nodes based on closeness to specified cg point
+    if symmetry:
+        idx = ny - 1
+    else:
+        idx = (ny - 1) // 2
+
+    index = 6 * idx
+    num_dofs = 6 * ny
+    arange = np.arange(6)
+
+    # Fixed boundary condition.
+    rows6 = index + arange
+    cols6 = num_dofs + arange
+
+    rows = np.concatenate([rows1, rows2, rows3, rows4, rows5, rows6, cols6])
+    cols = np.concatenate([cols1, cols2, cols3, cols4, cols5, cols6, rows6])
+
+    # vectorize for multiple RHS
+    sp_size = len(rows)
+    vec_rows = np.tile(rows, vec_size) + np.repeat(sp_size * np.arange(vec_size), sp_size)
+    vec_cols = np.tile(cols, vec_size) + np.repeat(sp_size * np.arange(vec_size), sp_size)
+
+    return rows, cols, vec_rows, vec_cols
+
+
+def get_drdK_sparsity_pattern(ny):
+    """
+    return sparsity pattern of partials of residuals w.r.t. stiffness matrix
+    """
+    base_row = np.tile(0, 12)
+    base_col = np.arange(12)
+    row = np.tile(base_row, 12) + np.repeat(np.arange(12), 12)
+    col = np.tile(base_col, 12) + np.repeat(12 * np.arange(12), 12)
+    rows = np.tile(row, ny - 1) + np.repeat(6 * np.arange(ny - 1), 144)
+    cols = np.tile(col, ny - 1) + np.repeat(144 * np.arange(ny - 1), 144)
+    return rows, cols
+
+
 class FEM(om.ImplicitComponent):
     """
     Component that solves a linear system, Ax=b.
@@ -78,64 +146,12 @@ def setup(self):
 
         # The derivative of residual wrt displacements is the stiffness matrix K. We can use the
         # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
-
-        base_row = np.repeat(0, 6)
-        base_col = np.arange(6)
-
-        # Upper diagonal blocks
-        rows1 = np.tile(base_row, 6 * (ny - 1)) + np.repeat(np.arange(6 * (ny - 1)), 6)
-        col = np.tile(base_col + 6, 6)
-        cols1 = np.tile(col, ny - 1) + np.repeat(6 * np.arange(ny - 1), 36)
-
-        # Lower diagonal blocks
-        rows2 = np.tile(base_row + 6, 6 * (ny - 1)) + np.repeat(np.arange(6 * (ny - 1)), 6)
-        col = np.tile(base_col, 6)
-        cols2 = np.tile(col, ny - 1) + np.repeat(6 * np.arange(ny - 1), 36)
-
-        # Main diagonal blocks, root
-        rows3 = np.tile(base_row, 6) + np.repeat(np.arange(6), 6)
-        cols3 = np.tile(base_col, 6)
-
-        # Main diagonal blocks, tip
-        rows4 = np.tile(base_row + (ny - 1) * 6, 6) + np.repeat(np.arange(6), 6)
-        cols4 = np.tile(base_col + (ny - 1) * 6, 6)
-
-        # Main diagonal blocks, interior
-        rows5 = np.tile(base_row + 6, 6 * (ny - 2)) + np.repeat(np.arange(6 * (ny - 2)), 6)
-        col = np.tile(base_col + 6, 6)
-        cols5 = np.tile(col, ny - 2) + np.repeat(6 * np.arange(ny - 2), 36)
-
-        # Find constrained nodes based on closeness to specified cg point
-        symmetry = self.options["surface"]["symmetry"]
-        if symmetry:
-            idx = self.ny - 1
-        else:
-            idx = (self.ny - 1) // 2
-
-        index = 6 * idx
-        num_dofs = 6 * ny
-        arange = np.arange(6)
-
-        # Fixed boundary condition.
-        rows6 = index + arange
-        cols6 = num_dofs + arange
-
-        self.k_rows = rows = np.concatenate([rows1, rows2, rows3, rows4, rows5, rows6, cols6])
-        self.k_cols = cols = np.concatenate([cols1, cols2, cols3, cols4, cols5, cols6, rows6])
-
-        sp_size = len(rows)
-        vec_rows = np.tile(rows, vec_size) + np.repeat(sp_size * np.arange(vec_size), sp_size)
-        vec_cols = np.tile(cols, vec_size) + np.repeat(sp_size * np.arange(vec_size), sp_size)
-
+        rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, self.options["surface"]["symmetry"])
+        self.k_rows = rows
+        self.k_cols = cols
         self.declare_partials(of="disp_aug", wrt="disp_aug", rows=vec_rows, cols=vec_cols)
 
-        base_row = np.tile(0, 12)
-        base_col = np.arange(12)
-        row = np.tile(base_row, 12) + np.repeat(np.arange(12), 12)
-        col = np.tile(base_col, 12) + np.repeat(12 * np.arange(12), 12)
-        rows = np.tile(row, ny - 1) + np.repeat(6 * np.arange(ny - 1), 144)
-        cols = np.tile(col, ny - 1) + np.repeat(144 * np.arange(ny - 1), 144)
-
+        rows, cols = get_drdK_sparsity_pattern(ny)
         self.declare_partials("disp_aug", "local_stiff_transformed", rows=rows, cols=cols)
 
     def apply_nonlinear(self, inputs, outputs, residuals):
diff --git a/openaerostruct/structures/fem_truss_braced.py b/openaerostruct/structures/fem_truss_braced.py
new file mode 100644
index 000000000..716e81fb4
--- /dev/null
+++ b/openaerostruct/structures/fem_truss_braced.py
@@ -0,0 +1,339 @@
+"""Define the LinearSystemComp class."""
+
+import numpy as np
+from scipy.sparse import coo_matrix
+from scipy.sparse.linalg import splu
+
+import openmdao.api as om
+
+from .fem import get_drdu_sparsity_pattern, get_drdK_sparsity_pattern
+
+
+class FEMTrussBraced(om.ImplicitComponent):
+    """
+    Component that solves an FEM linear system, K u = f.
+    This component is a customization of original fem.py to solve truss-braced wing structure.
+
+    This solve the following linear system for the wing-truss joint problem:
+    
+    [ K1 | 0  | C1^T ] [u1]       [f1]
+    [ 0  | K2 | C2^T ] [u2]     = [f2]
+    [ C1 | C2 | 0    ] [lambda]   [0 ]
+
+    where:
+        K1     = the stiffness matrix of the wing + additional entries for wing root boundary conditions
+        u1     = augmented displacement of the wing (includes Lagrange multipliers for boundary conditions)
+        f1     = augmented force vector of the wing (includes zeros at the end for boundary conditions)
+        K2     = the stiffness matrix of the truss + additional entries for truss root boundary conditions
+        u2     = augmented displacement of the truss (includes Lagrange multipliers for boundary conditions)
+        f2     = augmented force vector of the truss (includes zeros at the end for boundary conditions)
+        C1, C2 = constraint matrix for the wing-truss joint
+        lambda = Lagrange multipliers for the joint constraints (physically these are joint reaction forces)
+
+    Attributes
+    ----------
+    _lup : None or list(object)
+        matrix factorizations returned from scipy.linag.lu_factor for each A matrix
+    k_cols : ndarray
+        Cached column indices for sparse representation of stiffness matrix.
+    k_rows : ndarray
+        Cached row indices for sparse representation of stiffness matrix.
+    k_data : ndarray
+        Cached values for sparse representation of stiffness matrix.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Intialize the LinearSystemComp component.
+
+        Parameters
+        ----------
+        kwargs : dict of keyword arguments
+            Keyword arguments that will be mapped into the Component options.
+        """
+        super(FEMTrussBraced, self).__init__(**kwargs)
+        self._lup = None
+        self.k_cols = None
+        self.k_rows = None
+        self.k_data = None
+
+    def initialize(self):
+        """
+        Declare options.
+        """
+        self.options.declare("surfaces", types=list)
+        self.options.declare("vec_size", types=int, default=1, desc="Number of linear systems to solve.")
+
+    def setup(self):
+        """
+        Matrix and RHS are inputs, solution vector is the output.
+        """
+        vec_size = self.options["vec_size"]
+        self.surfaces = self.options["surfaces"]
+        if len(self.surfaces) != 2:
+            raise ValueError("FEMTrussBraced component requires exactly two surfaces (wing and truss).")
+        self.surface_names = [self.surfaces[0]["name"], self.surfaces[1]["name"]]
+        self.ny = []  # number of spanwise nodes
+        self.size = []   # size of assembled K matrix for each surface
+        self.num_k_data = []  # number of non-zero entries for assembled K matrix for each surface
+        self._lup = []
+        k_cols = []  # column indices for stiffness matrix sparsity pattern
+        k_rows = []  # row indices for stiffness matrix sparsity pattern
+        joint_indices = []   # node index for the joint between wing and truss
+
+        for i, surface in enumerate(self.surfaces):
+            name = surface["name"]
+
+            # --- inputs, outputs, partials of FEM system for each surface ---
+            ny = surface["mesh"].shape[1]
+            size = int(6 * ny + 6)
+            self.ny.append(ny)
+            self.size.append(size)
+            
+            full_size = size * vec_size
+            shape = (vec_size, size) if vec_size > 1 else (size,)
+            init_locK = np.tile(np.eye(12).flatten(), ny - 1).reshape(ny - 1, 12, 12)
+            self.add_input(f"local_stiff_transformed_{name}", val=init_locK)
+            self.add_input(f"forces_{name}", val=np.ones(shape), units="N")
+            self.add_output(f"disp_aug_{name}", shape=shape, val=0.1, units="m")
+
+            # Set up the derivatives.
+            row_col = np.arange(full_size, dtype="int")
+            self.declare_partials(f"disp_aug_{name}", f"forces_{name}", val=np.full(full_size, -1.0), rows=row_col, cols=row_col)
+
+            # The derivative of residual wrt displacements is the stiffness matrix K. We can use the
+            # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
+            rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"])
+            if i == 1:
+                # the second surface (truss) goes to the lower-right block of the entire stiffness matrix
+                rows += self.size[0]
+                cols += self.size[0]
+            k_rows.append(rows)
+            k_cols.append(cols)
+            self.num_k_data.append(len(rows))
+            self.declare_partials(of=f"disp_aug_{name}", wrt=f"disp_aug_{name}", rows=vec_rows, cols=vec_cols)
+
+            rows, cols = get_drdK_sparsity_pattern(ny)
+            self.declare_partials(f"disp_aug_{name}", f"local_stiff_transformed_{name}", rows=rows, cols=cols)
+
+        # --- joint constraints (coupling terms between two surfaces) ---
+        joint_type = self.surfaces[0]["joint_type"]
+        if joint_type == 'pin':
+            self.n_con = n_con = 3   # number of joint constraints: translational only
+        elif joint_type == 'rigid':
+            self.n_con = n_con = 6   # number of joint constraints: translational and rotational
+        else:
+            raise ValueError("Joint type must be either 'pin' or 'rigid'.")
+
+        # add Lagrange multipliers for joint constraints as state variables
+        self.add_output("joint_Lag", shape=(n_con,), val=0.0)
+
+        k_rows_joint = []
+        k_cols_joint = []
+        self.k_data_joint = []
+        for i, surface in enumerate(self.surfaces):
+            name = surface["name"]
+
+            # find the node index for the joint
+            joint_y = surface["joint_y"]
+            if not surface["symmetry"]:
+                raise NotImplementedError("Truss-braced wing joint is only implemented for symmetric surfaces.")
+            # check sign convention for y (spanwise coordinate)
+            if joint_y * surface["mesh"][0, 0, 1] < 0:
+                joint_y *= -1
+
+            joint_idx = np.argmin(np.abs(surface["mesh"][0, :, 1] - joint_y))
+            joint_indices.append(joint_idx)
+            print("Surface", name, "joint y:", surface["mesh"][0, joint_idx, 1], "joint index:", joint_idx)
+
+            # partials of joint constraint residuals w.r.t. displacement
+            rows = np.arange(n_con)
+            cols = np.arange(n_con) + 6 * joint_idx
+            if i == 0:
+                vals = np.ones(n_con) * 1e9
+            else:
+                vals = np.ones(n_con) * -1e9
+            self.declare_partials("joint_Lag", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+
+            # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
+            self.declare_partials(f"disp_aug_{name}", "joint_Lag", rows=cols, cols=rows, val=vals)
+
+            # append these entries to the bottom and right of the entire K matrix
+            rows += self.size[0] + self.size[1]
+            if i == 1:
+                cols += self.size[0]
+
+            # partials of joint constraint residuals w.r.t. local stiffness matrix
+            k_rows_joint.append(rows)
+            k_cols_joint.append(cols)
+            self.k_data_joint.append(vals)
+            # partials of FEM residuals wrt joint Lagrange multipliers
+            k_rows_joint.append(cols)
+            k_cols_joint.append(rows)
+            self.k_data_joint.append(vals)
+
+        # row and col indices for the entire stiffness matrix (that combines wing, truss, and joint constraints)
+        self.k_cols = np.concatenate(k_cols + k_cols_joint)
+        self.k_rows = np.concatenate(k_rows + k_rows_joint)
+        self.total_size = sum(self.size) + n_con   # size of total stiffness matrix (wing + truss + constraints)
+
+    def apply_nonlinear(self, inputs, outputs, residuals):
+        """
+        R = Ax - b.
+
+        Parameters
+        ----------
+        inputs : Vector
+            unscaled, dimensional input variables read via inputs[key]
+        outputs : Vector
+            unscaled, dimensional output variables read via outputs[key]
+        residuals : Vector
+            unscaled, dimensional residuals written to via residuals[key]
+        """
+        K = self.assemble_CSC_K(inputs)
+        disp = np.concatenate([outputs[f"disp_aug_{name}"] for name in self.surface_names])
+        joint_Lag = outputs["joint_Lag"]
+        u = np.concatenate([disp, joint_Lag])
+        force = np.concatenate([inputs[f"forces_{name}"] for name in self.surface_names])
+        rhs = np.concatenate([force, np.zeros(self.n_con)])
+
+        r = K.dot(u) - rhs
+
+        size0, size1 = self.size[0], self.size[1]  # size of each residuals
+        residuals[f"disp_aug_{self.surface_names[0]}"] = r[:size0]
+        residuals[f"disp_aug_{self.surface_names[1]}"] = r[size0:size0 + size1]
+        residuals["joint_Lag"] = r[size0 + size1:]
+        
+    def solve_nonlinear(self, inputs, outputs):
+        """
+        Use numpy to solve Ax=b for x.
+
+        Parameters
+        ----------
+        inputs : Vector
+            unscaled, dimensional input variables read via inputs[key]
+        outputs : Vector
+            unscaled, dimensional output variables read via outputs[key]
+        """
+        # lu factorization for use with solve_linear
+        K = self.assemble_CSC_K(inputs)
+        self._lup = splu(K)
+        force = np.concatenate([inputs[f"forces_{name}"] for name in self.surface_names])
+        rhs = np.concatenate([force, np.zeros(self.n_con)])
+
+        u = self._lup.solve(rhs)
+
+        size0, size1 = self.size[0], self.size[1]  # size of each displacement vectors
+        outputs[f"disp_aug_{self.surface_names[0]}"] = u[:size0]
+        outputs[f"disp_aug_{self.surface_names[1]}"] = u[size0:size0 + size1]
+        outputs["joint_Lag"] = u[size0 + size1:]
+
+    def linearize(self, inputs, outputs, J):
+        """
+        Compute the non-constant partial derivatives.
+
+        Parameters
+        ----------
+        inputs : Vector
+            unscaled, dimensional input variables read via inputs[key]
+        outputs : Vector
+            unscaled, dimensional output variables read via outputs[key]
+        J : Jacobian
+            sub-jac components written to jacobian[output_name, input_name]
+        """
+        vec_size = self.options["vec_size"]
+
+        name0, name1 = self.surface_names[0], self.surface_names[1]
+        ny0, ny1 = self.ny[0], self.ny[1]
+        idx0 = np.tile(np.tile(np.arange(12), 12), ny0 - 1) + np.repeat(6 * np.arange(ny0 - 1), 144)
+        idx1 = np.tile(np.tile(np.arange(12), 12), ny1 - 1) + np.repeat(6 * np.arange(ny1 - 1), 144)
+        disp0 = outputs[f"disp_aug_{name0}"]
+        disp1 = outputs[f"disp_aug_{name1}"]
+        J[f"disp_aug_{name0}", f"local_stiff_transformed_{name0}"] = np.tile(disp0[idx0], vec_size)
+        J[f"disp_aug_{name1}", f"local_stiff_transformed_{name1}"] = np.tile(disp1[idx1], vec_size)
+
+        nk0, nk1 = self.num_k_data[0], self.num_k_data[1]
+        k_data0 = self.k_data[:nk0]
+        k_data1 = self.k_data[nk0:nk0 + nk1]
+        J[f"disp_aug_{name0}", f"disp_aug_{name0}"] = np.tile(k_data0, vec_size)
+        J[f"disp_aug_{name1}", f"disp_aug_{name1}"] = np.tile(k_data1, vec_size)
+
+    def solve_linear(self, d_outputs, d_residuals, mode):
+        r"""
+        Back-substitution to solve the derivatives of the linear system.
+
+        If mode is:
+            'fwd': d_residuals \|-> d_outputs
+
+            'rev': d_outputs \|-> d_residuals
+
+        Parameters
+        ----------
+        d_outputs : Vector
+            unscaled, dimensional quantities read via d_outputs[key]
+        d_residuals : Vector
+            unscaled, dimensional quantities read via d_residuals[key]
+        mode : str
+            either 'fwd' or 'rev'
+        """
+        vec_size = self.options["vec_size"]
+        size0, size1 = self.size[0], self.size[1]
+        name0, name1 = self.surface_names[0], self.surface_names[1]
+
+        # TODO: verify (check_partials doesn't cover this)
+
+        if mode == "fwd":
+            if vec_size > 1:
+                for j in range(vec_size):
+                    rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"][j], d_residuals[f"disp_aug_{name1}"][j], d_residuals["joint_Lag"][j]))
+                    sol = self._lup.solve(rhs)
+                    d_outputs[f"disp_aug_{name0}"][j] = sol[:size0]
+                    d_outputs[f"disp_aug_{name1}"][j] = sol[size0:size0 + size1]
+                    d_outputs["joint_Lag"][j] = sol[size0 + size1:]
+            else:
+                rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"], d_residuals[f"disp_aug_{name1}"], d_residuals["joint_Lag"]))
+                sol = self._lup.solve(rhs)
+                d_outputs[f"disp_aug_{name0}"] = sol[:size0]
+                d_outputs[f"disp_aug_{name1}"] = sol[size0:size0 + size1]
+                d_outputs["joint_Lag"] = sol[size0 + size1:]
+        else:
+            if vec_size > 1:
+                for j in range(vec_size):
+                    rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"][j], d_outputs[f"disp_aug_{name1}"][j], d_outputs["joint_Lag"][j]))
+                    sol = self._lup.solve(rhs)
+                    d_residuals[f"disp_aug_{name0}"][j] = sol[:size0]
+                    d_residuals[f"disp_aug_{name1}"][j] = sol[size0:size0 + size1]
+                    d_residuals["joint_Lag"][j] = sol[size0 + size1:]
+            else:
+                rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"], d_outputs[f"disp_aug_{name1}"], d_outputs["joint_Lag"]))
+                sol = self._lup.solve(rhs)
+                d_residuals[f"disp_aug_{name0}"] = sol[:size0]
+                d_residuals[f"disp_aug_{name1}"] = sol[size0:size0 + size1]
+                d_residuals["joint_Lag"] = sol[size0 + size1:]
+
+    def assemble_CSC_K(self, inputs):
+        """
+        Assemble the stiffness matrix in sparse CSC format.
+
+        Returns
+        -------
+        ndarray
+            Stiffness matrix as dense ndarray.
+        """
+        data = {}
+        for surface in self.surfaces:
+            name = surface["name"]
+            k_loc = inputs[f"local_stiff_transformed_{name}"]
+
+            data1 = k_loc[:, :6, 6:].flatten()
+            data2 = k_loc[:, 6:, :6].flatten()
+            data3 = k_loc[0, :6, :6].flatten()
+            data4 = k_loc[-1, 6:, 6:].flatten()
+            data5 = (k_loc[0:-1, 6:, 6:] + k_loc[1:, :6, :6]).flatten()
+            data6 = np.full((6,), 1e9)
+            data[name] = np.concatenate([data1, data2, data3, data4, data5, data6, data6])
+
+        # combine matrices for wing, truss, and joint constraints
+        self.k_data = np.concatenate(list(data.values()) + self.k_data_joint)
+
+        return coo_matrix((self.k_data, (self.k_rows, self.k_cols)), shape=(self.total_size, self.total_size)).tocsc()
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index 4206d619b..13f0ef4cf 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -1,6 +1,7 @@
 import openmdao.api as om
 from openaerostruct.structures.create_rhs import CreateRHS
 from openaerostruct.structures.fem import FEM
+from openaerostruct.structures.fem_truss_braced import FEMTrussBraced
 from openaerostruct.structures.disp import Disp
 from openaerostruct.structures.wing_weight_loads import StructureWeightLoads
 from openaerostruct.structures.fuel_loads import FuelLoads
@@ -9,8 +10,35 @@
 from openaerostruct.structures.compute_thrust_loads import ComputeThrustLoads
 
 
-class SpatialBeamStates(om.Group):
-    """Group that contains the spatial beam states."""
+class FEMloads(om.Group):
+    """
+    Compute FEM right-hand side force vector
+
+    Parameters
+    ----------
+    nodes : ndarray
+        The coordinates of the FEM nodes.
+    load_factor : float
+        The load factor applied to the structure.
+    element_mass : ndarray
+        The mass of each element in the structure for bending relief.
+    fuel_mass : ndarray
+        Total fuel mass for bendling relief
+    fuel_vols : ndarray
+        The feul volume of each element
+    point_mass_locations : ndarray
+        The locations of the point masses.
+    point_masses : ndarray
+        Point masses as point load
+    engine_thrusts : ndarray
+        Engine thrusts as point load
+
+    Returns
+    -------
+    forces : ndarray
+        The right-hand side force vector for the FEM. This is a flattened array of loads
+        plus zeros at the end for boundary condition
+    """
 
     def initialize(self):
         self.options.declare("surface", types=dict)
@@ -65,6 +93,34 @@ def setup(self):
             "create_rhs", CreateRHS(surface=surface), promotes_inputs=["total_loads"], promotes_outputs=["forces"]
         )
 
-        self.add_subsystem("fem", FEM(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
 
-        self.add_subsystem("disp", Disp(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
+class SpatialBeamStates(om.Group):
+    """Group that contains the spatial beam states."""
+
+    def initialize(self):
+        self.options.declare("surface", types=(dict, list))
+        self.options.declare("truss_braced", default=False, types=bool)
+
+    def setup(self):
+        surface = self.options["surface"]
+
+        if not self.options["truss_braced"]:
+            self.add_subsystem('forces', FEMloads(surface=surface), promotes_inputs=["*"], promotes_outputs=["forces"])
+            self.add_subsystem("fem", FEM(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
+            self.add_subsystem("disp", Disp(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
+
+        else:
+            # compute RHS force vector for wing and truss, respectively
+            for surf in surface:
+                name = surf["name"]
+                self.add_subsystem(f'forces_{name}', FEMloads(surface=surf))
+                self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
+
+            # FEM of wing-truss system
+            self.add_subsystem("fem", FEMTrussBraced(surfaces=surface), promotes_inputs=["local_stiff_transformed_*"])
+            
+            # reshape displacements and remove Lagrange multipliers from disp_aug
+            for surf in surface:
+                name = surf["name"]
+                self.add_subsystem(f"disp_{name}", Disp(surface=surf), promotes_outputs=[("disp", f"disp_{name}")])
+                self.connect(f"fem.disp_aug_{name}", f"disp_{name}.disp_aug")

From ed9dcbbe3256073267be93ced4a73f7ee2f1e5d2 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Tue, 20 May 2025 18:13:42 -0400
Subject: [PATCH 02/30] renamed truss to strut

---
 ...em_truss_braced.py => fem_strut_braced.py} | 34 +++++++++++--------
 .../structures/spatial_beam_states.py         | 12 +++----
 2 files changed, 25 insertions(+), 21 deletions(-)
 rename openaerostruct/structures/{fem_truss_braced.py => fem_strut_braced.py} (93%)

diff --git a/openaerostruct/structures/fem_truss_braced.py b/openaerostruct/structures/fem_strut_braced.py
similarity index 93%
rename from openaerostruct/structures/fem_truss_braced.py
rename to openaerostruct/structures/fem_strut_braced.py
index 716e81fb4..6487a3610 100644
--- a/openaerostruct/structures/fem_truss_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -8,13 +8,17 @@
 
 from .fem import get_drdu_sparsity_pattern, get_drdK_sparsity_pattern
 
+# TODO:
+# - implement ball and pin joint (current pin joint should be renamed to ball)
+# - implement pin/ball joint for the root symmetric boundary
 
-class FEMTrussBraced(om.ImplicitComponent):
+
+class FEMStrutBraced(om.ImplicitComponent):
     """
     Component that solves an FEM linear system, K u = f.
-    This component is a customization of original fem.py to solve truss-braced wing structure.
+    This component is a customization of original fem.py to solve strut-braced wing structure.
 
-    This solve the following linear system for the wing-truss joint problem:
+    This solve the following linear system for the wing-strut joint problem:
     
     [ K1 | 0  | C1^T ] [u1]       [f1]
     [ 0  | K2 | C2^T ] [u2]     = [f2]
@@ -24,10 +28,10 @@ class FEMTrussBraced(om.ImplicitComponent):
         K1     = the stiffness matrix of the wing + additional entries for wing root boundary conditions
         u1     = augmented displacement of the wing (includes Lagrange multipliers for boundary conditions)
         f1     = augmented force vector of the wing (includes zeros at the end for boundary conditions)
-        K2     = the stiffness matrix of the truss + additional entries for truss root boundary conditions
-        u2     = augmented displacement of the truss (includes Lagrange multipliers for boundary conditions)
-        f2     = augmented force vector of the truss (includes zeros at the end for boundary conditions)
-        C1, C2 = constraint matrix for the wing-truss joint
+        K2     = the stiffness matrix of the strut + additional entries for strut root boundary conditions
+        u2     = augmented displacement of the strut (includes Lagrange multipliers for boundary conditions)
+        f2     = augmented force vector of the strut (includes zeros at the end for boundary conditions)
+        C1, C2 = constraint matrix for the wing-strut joint
         lambda = Lagrange multipliers for the joint constraints (physically these are joint reaction forces)
 
     Attributes
@@ -51,7 +55,7 @@ def __init__(self, **kwargs):
         kwargs : dict of keyword arguments
             Keyword arguments that will be mapped into the Component options.
         """
-        super(FEMTrussBraced, self).__init__(**kwargs)
+        super(FEMStrutBraced, self).__init__(**kwargs)
         self._lup = None
         self.k_cols = None
         self.k_rows = None
@@ -71,7 +75,7 @@ def setup(self):
         vec_size = self.options["vec_size"]
         self.surfaces = self.options["surfaces"]
         if len(self.surfaces) != 2:
-            raise ValueError("FEMTrussBraced component requires exactly two surfaces (wing and truss).")
+            raise ValueError("FEMStrutBraced component requires exactly two surfaces (wing and strut).")
         self.surface_names = [self.surfaces[0]["name"], self.surfaces[1]["name"]]
         self.ny = []  # number of spanwise nodes
         self.size = []   # size of assembled K matrix for each surface
@@ -79,7 +83,7 @@ def setup(self):
         self._lup = []
         k_cols = []  # column indices for stiffness matrix sparsity pattern
         k_rows = []  # row indices for stiffness matrix sparsity pattern
-        joint_indices = []   # node index for the joint between wing and truss
+        joint_indices = []   # node index for the joint between wing and strut
 
         for i, surface in enumerate(self.surfaces):
             name = surface["name"]
@@ -105,7 +109,7 @@ def setup(self):
             # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
             rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"])
             if i == 1:
-                # the second surface (truss) goes to the lower-right block of the entire stiffness matrix
+                # the second surface (strut) goes to the lower-right block of the entire stiffness matrix
                 rows += self.size[0]
                 cols += self.size[0]
             k_rows.append(rows)
@@ -137,7 +141,7 @@ def setup(self):
             # find the node index for the joint
             joint_y = surface["joint_y"]
             if not surface["symmetry"]:
-                raise NotImplementedError("Truss-braced wing joint is only implemented for symmetric surfaces.")
+                raise NotImplementedError("Strut-braced wing joint is only implemented for symmetric surfaces.")
             # check sign convention for y (spanwise coordinate)
             if joint_y * surface["mesh"][0, 0, 1] < 0:
                 joint_y *= -1
@@ -172,10 +176,10 @@ def setup(self):
             k_cols_joint.append(rows)
             self.k_data_joint.append(vals)
 
-        # row and col indices for the entire stiffness matrix (that combines wing, truss, and joint constraints)
+        # row and col indices for the entire stiffness matrix (that combines wing, strut, and joint constraints)
         self.k_cols = np.concatenate(k_cols + k_cols_joint)
         self.k_rows = np.concatenate(k_rows + k_rows_joint)
-        self.total_size = sum(self.size) + n_con   # size of total stiffness matrix (wing + truss + constraints)
+        self.total_size = sum(self.size) + n_con   # size of total stiffness matrix (wing + strut + constraints)
 
     def apply_nonlinear(self, inputs, outputs, residuals):
         """
@@ -333,7 +337,7 @@ def assemble_CSC_K(self, inputs):
             data6 = np.full((6,), 1e9)
             data[name] = np.concatenate([data1, data2, data3, data4, data5, data6, data6])
 
-        # combine matrices for wing, truss, and joint constraints
+        # combine matrices for wing, strut, and joint constraints
         self.k_data = np.concatenate(list(data.values()) + self.k_data_joint)
 
         return coo_matrix((self.k_data, (self.k_rows, self.k_cols)), shape=(self.total_size, self.total_size)).tocsc()
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index 13f0ef4cf..c2c63b2cd 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -1,7 +1,7 @@
 import openmdao.api as om
 from openaerostruct.structures.create_rhs import CreateRHS
 from openaerostruct.structures.fem import FEM
-from openaerostruct.structures.fem_truss_braced import FEMTrussBraced
+from openaerostruct.structures.fem_strut_braced import FEMStrutBraced
 from openaerostruct.structures.disp import Disp
 from openaerostruct.structures.wing_weight_loads import StructureWeightLoads
 from openaerostruct.structures.fuel_loads import FuelLoads
@@ -99,25 +99,25 @@ class SpatialBeamStates(om.Group):
 
     def initialize(self):
         self.options.declare("surface", types=(dict, list))
-        self.options.declare("truss_braced", default=False, types=bool)
+        self.options.declare("strut_braced", default=False, types=bool)
 
     def setup(self):
         surface = self.options["surface"]
 
-        if not self.options["truss_braced"]:
+        if not self.options["strut_braced"]:
             self.add_subsystem('forces', FEMloads(surface=surface), promotes_inputs=["*"], promotes_outputs=["forces"])
             self.add_subsystem("fem", FEM(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
             self.add_subsystem("disp", Disp(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
 
         else:
-            # compute RHS force vector for wing and truss, respectively
+            # compute RHS force vector for wing and strut, respectively
             for surf in surface:
                 name = surf["name"]
                 self.add_subsystem(f'forces_{name}', FEMloads(surface=surf))
                 self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
 
-            # FEM of wing-truss system
-            self.add_subsystem("fem", FEMTrussBraced(surfaces=surface), promotes_inputs=["local_stiff_transformed_*"])
+            # FEM of wing-strut system
+            self.add_subsystem("fem", FEMStrutBraced(surfaces=surface), promotes_inputs=["local_stiff_transformed_*"])
             
             # reshape displacements and remove Lagrange multipliers from disp_aug
             for surf in surface:

From 4e0c5bacf26f50c80f0198cca40837d4e1ae1d23 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Tue, 20 May 2025 23:53:29 -0400
Subject: [PATCH 03/30] modified AS group for strut-braced system

---
 .../integration/aerostruct_groups.py          | 42 ++++++++++++++-----
 .../structures/spatial_beam_states.py         |  2 +-
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 7eb1278be..1bd6de487 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -104,8 +104,10 @@ def setup(self):
 
 
 class CoupledAS(om.Group):
+    """ FEM + displacement transfer + VLM geometry property computations for single surface """
     def initialize(self):
         self.options.declare("surface", types=dict)
+        self.options.declare("include_FEM", default=True, types=bool, desc="If False, skip the FEM subsystem under this group; FEM should be added external to this group")
 
     def setup(self):
         surface = self.options["surface"]
@@ -120,12 +122,13 @@ def setup(self):
                 set(["point_mass_locations", "point_masses", "nodes", "load_factor", "engine_thrusts"])
             )
 
-        self.add_subsystem(
-            "struct_states",
-            SpatialBeamStates(surface=surface),
-            promotes_inputs=["local_stiff_transformed", "forces", "loads"] + promotes,
-            promotes_outputs=["disp"],
-        )
+        if self.options["include_FEM"]:
+            self.add_subsystem(
+                "struct_states",
+                SpatialBeamStates(surface=surface),
+                promotes_inputs=["local_stiff_transformed", "forces", "loads"] + promotes,
+                promotes_outputs=["disp"],
+            )
 
         self.add_subsystem(
             "def_mesh",
@@ -215,6 +218,7 @@ def initialize(self):
         self.options.declare(
             "rotational", False, types=bool, desc="Set to True to turn on support for computing angular velocities"
         )
+        self.options.declare("strut_braced", default=False, types=bool)
 
     def setup(self):
         surfaces = self.options["surfaces"]
@@ -222,13 +226,29 @@ def setup(self):
 
         coupled = om.Group()
 
+        if self.options["strut_braced"]:
+            if len(surfaces) != 2:
+                raise NameError("Strut-braced wing requires exactly two surfaces.")
+            # add FEM directly under the coupled group because multiple surfaces are coupled in the FEM level
+            coupled.add_subsystem(
+                "FEM_SBW",
+                SpatialBeamStates(surface=surfaces, strut_braced=True),
+                promotes_inputs=["*"],
+                promotes_outputs=["disp_*"]
+            )
+
         for surface in surfaces:
             name = surface["name"]
 
             # Connect the output of the loads component with the FEM
             # displacement parameter. This links the coupling within the coupled
             # group that necessitates the subgroup solver.
-            coupled.connect(name + "_loads.loads", name + ".loads")
+            loads_target = f"forces_{name}.loads" if self.options["strut_braced"] else f"{name}.loads"
+            coupled.connect(name + "_loads.loads", loads_target)
+
+            # Connect displacement from FEM to transfer model. This is automatically done by promotion for non-SBW cases
+            if self.options["strut_braced"]:
+                coupled.connect(f"disp_{name}", f"{name}.disp")
 
             # Perform the connections with the modified names within the
             # 'aero_states' group.
@@ -250,7 +270,8 @@ def setup(self):
 
             # Connect parameters from the 'coupled' group to the performance
             # groups for the individual surfaces.
-            self.connect("coupled." + name + ".disp", name + "_perf.disp")
+            disp_source = f"coupled.disp_{name}" if self.options["strut_braced"] else f"coupled.{name}.disp"
+            self.connect(disp_source, name + "_perf.disp")
             self.connect("coupled." + name + ".S_ref", name + "_perf.S_ref")
             self.connect("coupled." + name + ".widths", name + "_perf.widths")
             # self.connect('coupled.' + name + '.chords', name + '_perf.chords')
@@ -266,13 +287,14 @@ def setup(self):
             # Add components to the 'coupled' group for each surface.
             # The 'coupled' group must contain all components and parameters
             # needed to converge the aerostructural system.
-            coupled_AS_group = CoupledAS(surface=surface)
+            include_FEM = False if self.options["strut_braced"] else True   # For strut-braced case, FEM is already added outside of coupled AS
+            coupled_AS_group = CoupledAS(surface=surface, include_FEM=include_FEM)
 
             if (
                 surface["distributed_fuel_weight"]
                 or "n_point_masses" in surface.keys()
                 or surface["struct_weight_relief"]
-            ):
+            ) and not self.options["strut_braced"]:
                 prom_in = ["load_factor"]
             else:
                 prom_in = []
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index c2c63b2cd..95157a7dc 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -113,7 +113,7 @@ def setup(self):
             # compute RHS force vector for wing and strut, respectively
             for surf in surface:
                 name = surf["name"]
-                self.add_subsystem(f'forces_{name}', FEMloads(surface=surf))
+                self.add_subsystem(f'forces_{name}', FEMloads(surface=surf), promotes_inputs=["load_factor"])
                 self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
 
             # FEM of wing-strut system

From f067b8999aa6f403d7438c1cd8427bf457715df8 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Thu, 3 Jul 2025 17:57:13 +0900
Subject: [PATCH 04/30] added buckling components

---
 .../integration/aerostruct_groups.py          |  21 ++-
 .../structures/failure_buckling_ks.py         | 128 ++++++++++++++++++
 .../structures/spatial_beam_functionals.py    |  14 ++
 openaerostruct/structures/vonmises_wingbox.py |  28 ++++
 4 files changed, 178 insertions(+), 13 deletions(-)
 create mode 100644 openaerostruct/structures/failure_buckling_ks.py

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 1bd6de487..37d7c8cdc 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -183,22 +183,17 @@ def setup(self):
             )
 
         elif surface["fem_model_type"] == "wingbox":
+            promotes_inputs = ["Qz", "J", "A_enc", "spar_thickness", "htop", "hbottom", "hfront", "hrear", "nodes", "disp"]
+            promotes_outputs = ["vonmises", "failure"]
+            if "buckling" in surface and surface["buckling"]:
+                promotes_inputs += ["skin_thickness", "t_over_c", "fem_chords"]
+                promotes_outputs += ["failure_buckling"]
+
             self.add_subsystem(
                 "struct_funcs",
                 SpatialBeamFunctionals(surface=surface),
-                promotes_inputs=[
-                    "Qz",
-                    "J",
-                    "A_enc",
-                    "spar_thickness",
-                    "htop",
-                    "hbottom",
-                    "hfront",
-                    "hrear",
-                    "nodes",
-                    "disp",
-                ],
-                promotes_outputs=["vonmises", "failure"],
+                promotes_inputs=promotes_inputs,
+                promotes_outputs=promotes_outputs,
             )
         else:
             raise NameError("Please select a valid `fem_model_type` from either `tube` or `wingbox`.")
diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
new file mode 100644
index 000000000..d723ea739
--- /dev/null
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -0,0 +1,128 @@
+import numpy as np
+import openmdao.api as om
+
+
+class FailureBucklingKS(om.ExplicitComponent):
+    """
+    Buckling stress constraints for skin compression and spar shear buckling.
+    Returns KS-aggregated failure metric that should be constrained to be <= 0.
+
+    Source: Michael Niu, Airframe Stress Analysis and Sizing, Hong Kong Conmilit Press Ltd., 1997
+
+    The rho inputeter controls how conservatively the KS function aggregates
+    the failure constraints. A lower value is more conservative while a greater
+    value is more aggressive (closer approximation to the max() function).
+
+    parameters
+    ----------
+    upper_skin_comp_stress[ny-1] : numpy array
+        Compression stress in the upper skin for each FEM element.
+    lower_skin_comp_stress[ny-1] : numpy array
+        Compression stress in the lower skin for each FEM element.
+    front_spar_shear_stress[ny-1] : numpy array
+        Shear stress in the front spar for each FEM element.
+    rear_spar_shear_stress[ny-1] : numpy array
+        Shear stress in the rear spar for each FEM element.
+
+    Returns
+    -------
+    failure_buckling : float
+        KS aggregation quantity by combining the failure constraints from upper skin buckling,
+        front spar shear buckling, and rear spar shear buckling for all FEM elements.
+    upper_skin_buckling_margin[ny-1] : numpy array
+        Margin for upper skin buckling for each FEM element, should be >= 0
+        Margin = (buckling_limit - stress) / buckling_limit
+    front_spar_buckling_margin[ny-1] : numpy array
+        Margin for front spar shear buckling for each FEM element, should be >= 0
+    rear_spar_buckling_margin[ny-1] : numpy array
+        Margin for rear spar shear buckling for each FEM element, should be >= 0
+
+    """
+
+    def initialize(self):
+        self.options.declare("surface", types=dict)
+        self.options.declare("rho", types=float, default=100.0)
+
+    def setup(self):
+        surface = self.options["surface"]
+        rho = self.options["rho"]
+
+        if surface["fem_model_type"] == "tube":
+            raise NotImplementedError("FailureBucklingKS is not implemented for tube FEM model type")
+
+        self.ny = surface["mesh"].shape[1]
+
+        # stress of each element
+        self.add_input("upper_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+        self.add_input("lower_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+        self.add_input("front_spar_shear_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+        self.add_input("rear_spar_shear_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+        # wingbox geometry
+        self.add_input("skin_thickness", val=np.zeros(self.ny - 1), units="m")
+        self.add_input("spar_thickness", val=np.zeros(self.ny - 1), units="m")
+        self.add_input("t_over_c", val=np.ones((self.ny - 1)))
+        self.add_input("fem_chords", val=np.zeros(self.ny - 1), units="m")
+
+        self.add_output("failure_buckling", val=0.0)
+        # also output margins for each element/buckling for post-processing
+        # but don't declare partials for these outputs because we only use aggregated failure
+        self.add_output("upper_skin_buckling_margin", val=np.zeros(self.ny - 1), desc='(buckling_limit - stress) / buckling_limit >= 0?')
+        self.add_output("lower_skin_buckling_margin", val=np.zeros(self.ny - 1), desc='(buckling_limit - stress) / buckling_limit >= 0?')
+        self.add_output("front_spar_buckling_margin", val=np.zeros(self.ny - 1), desc='(buckling_limit - stress) / buckling_limit >= 0?')
+        self.add_output("rear_spar_buckling_margin", val=np.zeros(self.ny - 1), desc='(buckling_limit - stress) / buckling_limit >= 0?')
+
+        self.rho = rho
+
+        self.declare_partials("failure_buckling", "*", method="cs")
+
+    def compute(self, inputs, outputs):
+        surface = self.options["surface"]
+        E = self.options["surface"]["E"]
+        rib_pitch = self.options["surface"]["rib_pitch"]
+        rho = self.options["rho"]  # KS aggregation parameter
+
+        # --- compute buckling stress ---
+        # buckling model parameters
+        eff_factor = 0.88  # stiffened panel efficiency for skin compression buckling. From Fig. 14.4.4 in Niu 1997
+        Ks = 10.0  # model parameter for spar shear buckling. From Eq. 11.3.4 in Niu 1997
+
+        # buckling stress for skin compression. Eq. 14.4.2, Page 618 from Niu 1997
+        # Positive stress = compression.
+        load_intensity_upper = inputs["skin_thickness"] * inputs["upper_skin_comp_stress"]  # Pa*m
+        load_positive_upper = np.maximum(load_intensity_upper, 1.)  # NOTE: this is C1 discontinuous so may negatively affect convergence
+        sigma_max_upper = eff_factor * (load_positive_upper * E / rib_pitch)**0.5
+        load_intensity_lower = inputs["skin_thickness"] * inputs["lower_skin_comp_stress"]
+        load_positive_lower = np.maximum(load_intensity_lower, 1.)
+        sigma_max_lower = eff_factor * (load_positive_lower * E / rib_pitch)**0.5
+
+        # shear buckling stress of spars. Eq. 14.4.3, Page 618 from Niu 1997
+        t_over_c_orig = surface["original_wingbox_airfoil_t_over_c"]
+        spar_height_front_nondim = (surface["data_y_upper"][0] - surface["data_y_lower"][0])  # nondim height from wingbox cross-section
+        spar_height_rear_nondim = (surface["data_y_upper"][-1] - surface["data_y_lower"][-1])
+        spar_height_front = spar_height_front_nondim * inputs["fem_chords"] * (inputs["t_over_c"] / t_over_c_orig)
+        spar_height_rear = spar_height_rear_nondim * inputs["fem_chords"] * (inputs["t_over_c"] / t_over_c_orig)
+        tau_max_front = Ks * E * (inputs["spar_thickness"] / spar_height_front)**2
+        tau_max_rear = Ks * E * (inputs["spar_thickness"] / spar_height_rear)**2
+
+        # --- compute failure and stress margins ---
+        outputs["upper_skin_buckling_margin"] = (sigma_max_upper - inputs["upper_skin_comp_stress"]) / sigma_max_upper
+        outputs["lower_skin_buckling_margin"] = (sigma_max_lower - inputs["lower_skin_comp_stress"]) / sigma_max_lower
+        # apply 40% to shear stress based on Elham 2014, Effect of wing-box structure on the optimum wing outer shape, The Aeronautical Journal
+        outputs["front_spar_buckling_margin"] = (tau_max_front - inputs["front_spar_shear_stress"] * 0.4) / tau_max_front
+        outputs["rear_spar_buckling_margin"] = (tau_max_rear - inputs["rear_spar_shear_stress"] * 0.4) / tau_max_rear
+
+        # Failure criteria (must be <= 0)
+        failure_all = np.concatenate(
+            [
+                inputs["upper_skin_comp_stress"] / sigma_max_upper - 1,
+                inputs["lower_skin_comp_stress"] / sigma_max_lower - 1,
+                inputs["front_spar_shear_stress"] * 0.4 / tau_max_front - 1,
+                inputs["rear_spar_shear_stress"] * 0.4 / tau_max_rear - 1,
+            ]
+        )
+
+        fmax = np.max(failure_all)
+
+        nlog, nsum, nexp = np.log, np.sum, np.exp
+        ks = 1 / rho * nlog(nsum(nexp(rho * (failure_all - fmax))))
+        outputs["failure_buckling"] = fmax + ks
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index cff8cdd76..447e97cb9 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -8,6 +8,7 @@
 from openaerostruct.structures.non_intersecting_thickness import NonIntersectingThickness
 from openaerostruct.structures.failure_exact import FailureExact
 from openaerostruct.structures.failure_ks import FailureKS
+from openaerostruct.structures.failure_buckling_ks import FailureBucklingKS
 
 
 class SpatialBeamFunctionals(om.Group):
@@ -74,3 +75,16 @@ def setup(self):
             self.add_subsystem(
                 "failure", FailureKS(surface=surface), promotes_inputs=["vonmises"], promotes_outputs=["failure"]
             )
+
+        # compute buckling failure
+        if "buckling" in surface and surface["buckling"]:
+            self.add_subsystem(
+                "failure_buckling",
+                FailureBucklingKS(surface=surface),
+                promotes_inputs=["skin_thickness", "spar_thickness", "t_over_c", "fem_chords"],
+                promotes_outputs=["failure_buckling"]
+            )
+            self.connect("vonmises.upper_skin_comp_stress", "failure_buckling.upper_skin_comp_stress")
+            self.connect("vonmises.lower_skin_comp_stress", "failure_buckling.lower_skin_comp_stress")
+            self.connect("vonmises.front_spar_shear_stress", "failure_buckling.front_spar_shear_stress")
+            self.connect("vonmises.rear_spar_shear_stress", "failure_buckling.rear_spar_shear_stress")
diff --git a/openaerostruct/structures/vonmises_wingbox.py b/openaerostruct/structures/vonmises_wingbox.py
index 052bfbfef..115e6e404 100644
--- a/openaerostruct/structures/vonmises_wingbox.py
+++ b/openaerostruct/structures/vonmises_wingbox.py
@@ -42,6 +42,18 @@ class VonMisesWingbox(om.ExplicitComponent):
     -------
     vonmises[ny-1, 4] : numpy array
         von Mises stresses for 4 stress combinations for each FEM element.
+    upper_skin_comp_stress[ny-1] : numpy array
+        Optional output for buckling failure check.
+        Compression stress in the upper skin for each FEM element.
+    lower_skin_comp_stress[ny-1] : numpy array
+        Optional output for buckling failure check.
+        Compression stress in the lower skin for each FEM element.
+    front_spar_shear_stress[ny-1] : numpy array
+        Optional output for buckling failure check.
+        Shear stress in the front spar for each FEM element.
+    rear_spar_shear_stress[ny-1] : numpy array
+        Optional output for buckling failure check.
+        Shear stress in the rear spar for each FEM element.
 
     """
 
@@ -66,6 +78,14 @@ def setup(self):
 
         self.add_output("vonmises", val=np.zeros((self.ny - 1, 4)), units="N/m**2")
 
+        # also output upper skin's compression stress and spar shear stress for buckling
+        if "buckling" in self.surface and self.surface["buckling"]:
+            # positive = compression
+            self.add_output("upper_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+            self.add_output("lower_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+            self.add_output("front_spar_shear_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+            self.add_output("rear_spar_shear_stress", val=np.zeros(self.ny - 1), units="N/m**2")
+
         self.E = surface["E"]
         self.G = surface["G"]
 
@@ -164,3 +184,11 @@ def compute(self, inputs, outputs):
                 np.sqrt((rear_bending_stress + axial_stress) ** 2 + 3 * (torsion_stress + vertical_shear) ** 2)
                 / self.tssf
             )
+
+            # compute upper skin's compression stress and spar shear stress for buckling failure check
+            if "buckling" in self.surface and self.surface["buckling"]:
+                # flip sign to let positive = compression
+                outputs["upper_skin_comp_stress"][ielem] = -(axial_stress + top_bending_stress)
+                outputs["lower_skin_comp_stress"][ielem] = -(axial_stress + bottom_bending_stress)
+                outputs["front_spar_shear_stress"][ielem] = torsion_stress - vertical_shear
+                outputs["rear_spar_shear_stress"][ielem] = torsion_stress + vertical_shear

From 36fddefbbc35802bbdfb01e11eaa0897a73635f8 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Thu, 3 Jul 2025 21:27:59 +0900
Subject: [PATCH 05/30] added safety factor for buckling stress

---
 openaerostruct/structures/failure_buckling_ks.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
index d723ea739..968196129 100644
--- a/openaerostruct/structures/failure_buckling_ks.py
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -81,6 +81,8 @@ def compute(self, inputs, outputs):
         rib_pitch = self.options["surface"]["rib_pitch"]
         rho = self.options["rho"]  # KS aggregation parameter
 
+        safety_factor = 1.5
+
         # --- compute buckling stress ---
         # buckling model parameters
         eff_factor = 0.88  # stiffened panel efficiency for skin compression buckling. From Fig. 14.4.4 in Niu 1997
@@ -90,10 +92,10 @@ def compute(self, inputs, outputs):
         # Positive stress = compression.
         load_intensity_upper = inputs["skin_thickness"] * inputs["upper_skin_comp_stress"]  # Pa*m
         load_positive_upper = np.maximum(load_intensity_upper, 1.)  # NOTE: this is C1 discontinuous so may negatively affect convergence
-        sigma_max_upper = eff_factor * (load_positive_upper * E / rib_pitch)**0.5
+        sigma_max_upper = (eff_factor * (load_positive_upper * E / rib_pitch)**0.5) / safety_factor
         load_intensity_lower = inputs["skin_thickness"] * inputs["lower_skin_comp_stress"]
         load_positive_lower = np.maximum(load_intensity_lower, 1.)
-        sigma_max_lower = eff_factor * (load_positive_lower * E / rib_pitch)**0.5
+        sigma_max_lower = (eff_factor * (load_positive_lower * E / rib_pitch)**0.5) / safety_factor
 
         # shear buckling stress of spars. Eq. 14.4.3, Page 618 from Niu 1997
         t_over_c_orig = surface["original_wingbox_airfoil_t_over_c"]
@@ -101,8 +103,8 @@ def compute(self, inputs, outputs):
         spar_height_rear_nondim = (surface["data_y_upper"][-1] - surface["data_y_lower"][-1])
         spar_height_front = spar_height_front_nondim * inputs["fem_chords"] * (inputs["t_over_c"] / t_over_c_orig)
         spar_height_rear = spar_height_rear_nondim * inputs["fem_chords"] * (inputs["t_over_c"] / t_over_c_orig)
-        tau_max_front = Ks * E * (inputs["spar_thickness"] / spar_height_front)**2
-        tau_max_rear = Ks * E * (inputs["spar_thickness"] / spar_height_rear)**2
+        tau_max_front = (Ks * E * (inputs["spar_thickness"] / spar_height_front)**2) / safety_factor
+        tau_max_rear = (Ks * E * (inputs["spar_thickness"] / spar_height_rear)**2) / safety_factor
 
         # --- compute failure and stress margins ---
         outputs["upper_skin_buckling_margin"] = (sigma_max_upper - inputs["upper_skin_comp_stress"]) / sigma_max_upper

From fc02b9063b2932fab7d6bc82d48424f748b15cf7 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 16 Jul 2025 17:17:57 -0400
Subject: [PATCH 06/30] added Euler column buckling for strut

---
 .../integration/aerostruct_groups.py          |  6 +-
 .../structures/failure_buckling_ks.py         | 94 ++++++++++++++++++-
 .../structures/spatial_beam_functionals.py    | 26 +++--
 3 files changed, 112 insertions(+), 14 deletions(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 37d7c8cdc..a9bf12f43 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -187,7 +187,11 @@ def setup(self):
             promotes_outputs = ["vonmises", "failure"]
             if "buckling" in surface and surface["buckling"]:
                 promotes_inputs += ["skin_thickness", "t_over_c", "fem_chords"]
-                promotes_outputs += ["failure_buckling"]
+                promotes_outputs += ["failure_local_buckling"]
+                if surface["name"] == "strut":
+                    # additional inputs/outputs for column buckling
+                    promotes_inputs += ["Iz", "joint_load"]
+                    promotes_outputs += ["failure_column_buckling"]
 
             self.add_subsystem(
                 "struct_funcs",
diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
index 968196129..ef68e0c92 100644
--- a/openaerostruct/structures/failure_buckling_ks.py
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -2,9 +2,9 @@
 import openmdao.api as om
 
 
-class FailureBucklingKS(om.ExplicitComponent):
+class PanelLocalBucklingFailureKS(om.ExplicitComponent):
     """
-    Buckling stress constraints for skin compression and spar shear buckling.
+    Panel local buckling stress constraints for skin compression and spar shear buckling.
     Returns KS-aggregated failure metric that should be constrained to be <= 0.
 
     Source: Michael Niu, Airframe Stress Analysis and Sizing, Hong Kong Conmilit Press Ltd., 1997
@@ -63,7 +63,7 @@ def setup(self):
         self.add_input("t_over_c", val=np.ones((self.ny - 1)))
         self.add_input("fem_chords", val=np.zeros(self.ny - 1), units="m")
 
-        self.add_output("failure_buckling", val=0.0)
+        self.add_output("failure_local_buckling", val=0.0, desc="Local buckling failure metric, should be <= 0")
         # also output margins for each element/buckling for post-processing
         # but don't declare partials for these outputs because we only use aggregated failure
         self.add_output("upper_skin_buckling_margin", val=np.zeros(self.ny - 1), desc='(buckling_limit - stress) / buckling_limit >= 0?')
@@ -73,7 +73,7 @@ def setup(self):
 
         self.rho = rho
 
-        self.declare_partials("failure_buckling", "*", method="cs")
+        self.declare_partials("failure_local_buckling", "*", method="cs")
 
     def compute(self, inputs, outputs):
         surface = self.options["surface"]
@@ -127,4 +127,88 @@ def compute(self, inputs, outputs):
 
         nlog, nsum, nexp = np.log, np.sum, np.exp
         ks = 1 / rho * nlog(nsum(nexp(rho * (failure_all - fmax))))
-        outputs["failure_buckling"] = fmax + ks
+        outputs["failure_local_buckling"] = fmax + ks
+
+
+class EulerColumnBucklingFailureKS(om.ExplicitComponent):
+    """
+    Euler column buckling.
+
+    Given the EI (which varies along the strut span) and strut length, it computes the buckling critical load.
+    The critical load varies along the strut span.
+    We them impose:
+        critical_load >= column_compression_load (which comes from the joint reaction force)
+    This is converted to a failure metric:
+        failure = (column_compression_load - critical_load) / column_compression_load <= 0.
+    and will be KS-aggregated.
+
+    Parameters
+    ----------
+    nodes[ny, 3] : numpy array
+        FEM node coordinates.
+    joint_load[3] : numpy array
+        Force vector applied to the strut at the joint.
+    Iz[ny-1] : numpy array
+        Moment of inertia of the strut about the z-axis.
+
+    Returns
+    -------
+    failure_Euler_buckling : float
+        Euler column buckling failure metric, should be <= 0
+    Euler_buckling_margin[ny-1] : numpy array
+    """
+
+    def initialize(self):
+        self.options.declare("surface", types=dict)
+        self.options.declare("rho", types=float, default=100.0, desc="KS aggregation smoothness parameter")
+
+    def setup(self):
+        surface = self.options["surface"]
+        ny = surface["mesh"].shape[1]
+
+        self.add_input("nodes", shape=(ny, 3), units="m", desc="FEM node coordinates")
+        self.add_input("joint_load", shape=3, desc="load vector applied to the strut at the joint")
+        self.add_input("Iz", shape=(ny - 1), units="m**4")  # use Iz because Iz < Iy
+
+        self.add_output("failure_column_buckling", val=0.0, desc="Euler column buckling failure metric, should be <= 0")
+        self.add_output("column_buckling_margin", shape=(ny - 1), desc="Euler column buckling margin, should be >= 0")
+        # this buckling margin is only for post-processing, so don't declare partials for it
+
+        self.declare_partials("failure_column_buckling", ["joint_load", "Iz"], method="cs")
+        # we only use nodes[0, :] and nodes[-1, :], so declare the sparse partials
+        col_indices = [0, 1, 2, (ny * 3) - 3, (ny * 3) - 2, (ny * 3) - 1]
+        self.declare_partials("column_buckling_margin", "nodes", method="cs", rows=np.zeros(6), cols=col_indices)
+
+    def compute(self, inputs, outputs):
+        nodes = inputs["nodes"]
+        E = self.options["surface"]["E"]
+        joint_load = inputs["joint_load"]
+        Iz = inputs["Iz"]
+
+        # convert joint load to N (FEM normalizes this by 1e9, so we apply it back)
+        joint_load *= 1e9
+
+        # strut length
+        # The length we compute from the FEM nodes are longer than the actual length because e.g. we don't model fuselage so the strut root is at the symmetry plane.
+        # To account for this, apply a factor < 1 to the strut length.
+        column_length_factor = self.options["surface"]["column_length_factor"]
+        strut_len = np.linalg.norm(nodes[0, :] - nodes[-1, :]) * column_length_factor
+
+        # compression load
+        strut_direction = (nodes[-1, :] - nodes[0, :])
+        strut_direction /= np.linalg.norm(strut_direction)  # unit magniture
+        comp_load = np.dot(joint_load, strut_direction)  # flip sign to make compression = positive
+        
+        # critical load with safety factor of 1.5
+        sf = 1.5
+        P_crit = np.pi**2 * E * Iz / strut_len**2 / sf
+
+        # failure metric
+        outputs["column_buckling_margin"] = (P_crit - comp_load) / P_crit
+        
+        # KS-aggregated failure metric (should be <= 0)
+        failure_all = comp_load / P_crit - 1
+        fmax = np.max(failure_all)
+        rho = self.options["rho"]
+        ks = 1 / rho * np.log(np.sum(np.exp(rho * (failure_all - fmax))))
+        outputs["failure_column_buckling"] = fmax + ks
\ No newline at end of file
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index 447e97cb9..212b88423 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -8,7 +8,7 @@
 from openaerostruct.structures.non_intersecting_thickness import NonIntersectingThickness
 from openaerostruct.structures.failure_exact import FailureExact
 from openaerostruct.structures.failure_ks import FailureKS
-from openaerostruct.structures.failure_buckling_ks import FailureBucklingKS
+from openaerostruct.structures.failure_buckling_ks import PanelLocalBucklingFailureKS, EulerColumnBucklingFailureKS
 
 
 class SpatialBeamFunctionals(om.Group):
@@ -78,13 +78,23 @@ def setup(self):
 
         # compute buckling failure
         if "buckling" in surface and surface["buckling"]:
+            # skin panel buckling and spar shear buckling
             self.add_subsystem(
-                "failure_buckling",
-                FailureBucklingKS(surface=surface),
+                "local_buckling",
+                PanelLocalBucklingFailureKS(surface=surface),
                 promotes_inputs=["skin_thickness", "spar_thickness", "t_over_c", "fem_chords"],
-                promotes_outputs=["failure_buckling"]
+                promotes_outputs=["failure_local_buckling"]
             )
-            self.connect("vonmises.upper_skin_comp_stress", "failure_buckling.upper_skin_comp_stress")
-            self.connect("vonmises.lower_skin_comp_stress", "failure_buckling.lower_skin_comp_stress")
-            self.connect("vonmises.front_spar_shear_stress", "failure_buckling.front_spar_shear_stress")
-            self.connect("vonmises.rear_spar_shear_stress", "failure_buckling.rear_spar_shear_stress")
+            self.connect("vonmises.upper_skin_comp_stress", "local_buckling.upper_skin_comp_stress")
+            self.connect("vonmises.lower_skin_comp_stress", "local_buckling.lower_skin_comp_stress")
+            self.connect("vonmises.front_spar_shear_stress", "local_buckling.front_spar_shear_stress")
+            self.connect("vonmises.rear_spar_shear_stress", "local_buckling.rear_spar_shear_stress")
+
+            # global Euler column buckling
+            if surface["name"] == "strut":
+                self.add_subsystem(
+                    "column_buckling",
+                    EulerColumnBucklingFailureKS(surface=surface),
+                    promotes_inputs=["nodes", "joint_load", "Iz"],
+                    promotes_outputs=["failure_column_buckling"]
+                )

From 230fb3601d8bb2723ef8d0123afd5bb481026763 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 16 Jul 2025 18:49:45 -0400
Subject: [PATCH 07/30] support pin boundary condition for strut root

---
 openaerostruct/structures/create_rhs.py       | 10 ++++++++-
 openaerostruct/structures/disp.py             | 12 +++++++++--
 openaerostruct/structures/fem.py              |  9 +++++---
 openaerostruct/structures/fem_strut_braced.py | 21 ++++++++++++++++---
 4 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/openaerostruct/structures/create_rhs.py b/openaerostruct/structures/create_rhs.py
index 1992e27b2..870f3cd13 100644
--- a/openaerostruct/structures/create_rhs.py
+++ b/openaerostruct/structures/create_rhs.py
@@ -31,7 +31,15 @@ def setup(self):
         self.ny = surface["mesh"].shape[1]
 
         self.add_input("total_loads", val=np.zeros((self.ny, 6)), units="N")
-        self.add_output("forces", val=np.ones(((self.ny + 1) * 6)), units="N")
+
+        # shape of forces depends on the root boundary condition type
+        if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+            self.root_BC_pin = True
+            forces_size = self.ny * 6 + 3
+        else:
+            self.root_BC_pin = False
+            forces_size = (self.ny + 1) * 6
+        self.add_output("forces", val=np.ones((forces_size)), units="N")
 
         n = self.ny * 6
         arange = np.arange((n))
diff --git a/openaerostruct/structures/disp.py b/openaerostruct/structures/disp.py
index 8d5f1e85f..ce3f687f4 100644
--- a/openaerostruct/structures/disp.py
+++ b/openaerostruct/structures/disp.py
@@ -35,7 +35,15 @@ def setup(self):
 
         self.ny = surface["mesh"].shape[1]
 
-        self.add_input("disp_aug", val=np.zeros(((self.ny + 1) * 6)), units="m")
+        # shape of disp_aug depends on the root boundary condition type
+        if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+            self.root_BC_pin = True
+            disp_aug_size = self.ny * 6 + 3
+        else:
+            self.root_BC_pin = False
+            disp_aug_size = (self.ny + 1) * 6
+        self.add_input("disp_aug", val=np.zeros((disp_aug_size)), units="m")
+
         self.add_output("disp", val=np.zeros((self.ny, 6)), units="m")
 
         n = self.ny * 6
@@ -45,4 +53,4 @@ def setup(self):
     def compute(self, inputs, outputs):
         # Obtain the relevant portions of disp_aug and store the reshaped
         # displacements in disp
-        outputs["disp"] = inputs["disp_aug"][:-6].reshape((-1, 6))
+        outputs["disp"] = inputs["disp_aug"][:self.ny * 6].reshape((-1, 6))
diff --git a/openaerostruct/structures/fem.py b/openaerostruct/structures/fem.py
index 4c6492875..bb7c42fbd 100644
--- a/openaerostruct/structures/fem.py
+++ b/openaerostruct/structures/fem.py
@@ -7,7 +7,7 @@
 import openmdao.api as om
 
 
-def get_drdu_sparsity_pattern(ny, vec_size, symmetry):
+def get_drdu_sparsity_pattern(ny, vec_size, symmetry, root_BC_pin=False):
     """
     return sparsity pattern of partials of residuals w.r.t. displacements = stiffness matrix
     """
@@ -45,9 +45,12 @@ def get_drdu_sparsity_pattern(ny, vec_size, symmetry):
 
     index = 6 * idx
     num_dofs = 6 * ny
-    arange = np.arange(6)
 
-    # Fixed boundary condition.
+    # Fixed boundary condition. Number of additional "DoFs" varies depending on the root boundary condition type.
+    if root_BC_pin:
+        arange = np.arange(3)  # translation only
+    else:
+        arange = np.arange(6)  # translation and rotation
     rows6 = index + arange
     cols6 = num_dofs + arange
 
diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 6487a3610..9a954f454 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -90,7 +90,14 @@ def setup(self):
 
             # --- inputs, outputs, partials of FEM system for each surface ---
             ny = surface["mesh"].shape[1]
-            size = int(6 * ny + 6)
+            if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+                # pin boundary condition at the root
+                size = int(6 * ny + 3)
+                root_BC_pin = True
+            else:
+                # rigid boundary condition at the root
+                size = int(6 * ny + 6)
+                root_BC_pin = False
             self.ny.append(ny)
             self.size.append(size)
             
@@ -107,7 +114,7 @@ def setup(self):
 
             # The derivative of residual wrt displacements is the stiffness matrix K. We can use the
             # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
-            rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"])
+            rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"], root_BC_pin)
             if i == 1:
                 # the second surface (strut) goes to the lower-right block of the entire stiffness matrix
                 rows += self.size[0]
@@ -334,7 +341,15 @@ def assemble_CSC_K(self, inputs):
             data3 = k_loc[0, :6, :6].flatten()
             data4 = k_loc[-1, 6:, 6:].flatten()
             data5 = (k_loc[0:-1, 6:, 6:] + k_loc[1:, :6, :6]).flatten()
-            data6 = np.full((6,), 1e9)
+
+            # data6 corresponds to the root boundary condition
+            if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+                # for pin BC (constraint translation only)
+                data6 = np.full((3,), 1e9)
+            else:
+                # for rigid BC (constraint translation and rotation)
+                data6 = np.full((6,), 1e9)
+            
             data[name] = np.concatenate([data1, data2, data3, data4, data5, data6, data6])
 
         # combine matrices for wing, strut, and joint constraints

From 96962df57f0cdf0126a2e8f3318c175f77875265 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 16 Jul 2025 19:18:26 -0400
Subject: [PATCH 08/30] pin and ball boundary conditions for strut root

---
 openaerostruct/structures/create_rhs.py       | 12 ++++----
 openaerostruct/structures/disp.py             | 12 ++++----
 openaerostruct/structures/fem.py              | 20 +++++++++----
 openaerostruct/structures/fem_strut_braced.py | 29 ++++++++++++-------
 4 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/openaerostruct/structures/create_rhs.py b/openaerostruct/structures/create_rhs.py
index 870f3cd13..20bc56492 100644
--- a/openaerostruct/structures/create_rhs.py
+++ b/openaerostruct/structures/create_rhs.py
@@ -33,13 +33,13 @@ def setup(self):
         self.add_input("total_loads", val=np.zeros((self.ny, 6)), units="N")
 
         # shape of forces depends on the root boundary condition type
-        if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
-            self.root_BC_pin = True
-            forces_size = self.ny * 6 + 3
+        if "root_BC_type" in surface and surface["root_BC_type"] == "ball":
+            dof_of_boundary = 3  # translation only
+        elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+            dof_of_boundary = 5  # translation and rotation in y and z
         else:
-            self.root_BC_pin = False
-            forces_size = (self.ny + 1) * 6
-        self.add_output("forces", val=np.ones((forces_size)), units="N")
+            dof_of_boundary = 6  # translation and rotation
+        self.add_output("forces", val=np.ones((self.ny * 6 + dof_of_boundary)), units="N")
 
         n = self.ny * 6
         arange = np.arange((n))
diff --git a/openaerostruct/structures/disp.py b/openaerostruct/structures/disp.py
index ce3f687f4..44bc0f27f 100644
--- a/openaerostruct/structures/disp.py
+++ b/openaerostruct/structures/disp.py
@@ -36,13 +36,13 @@ def setup(self):
         self.ny = surface["mesh"].shape[1]
 
         # shape of disp_aug depends on the root boundary condition type
-        if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
-            self.root_BC_pin = True
-            disp_aug_size = self.ny * 6 + 3
+        if "root_BC_type" in surface and surface["root_BC_type"] == "ball":
+            dof_of_boundary = 3  # translation only
+        elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+            dof_of_boundary = 5  # translation and rotation in y and z
         else:
-            self.root_BC_pin = False
-            disp_aug_size = (self.ny + 1) * 6
-        self.add_input("disp_aug", val=np.zeros((disp_aug_size)), units="m")
+            dof_of_boundary = 6  # translation and rotation
+        self.add_input("disp_aug", val=np.zeros((self.ny * 6 + dof_of_boundary)), units="m")
 
         self.add_output("disp", val=np.zeros((self.ny, 6)), units="m")
 
diff --git a/openaerostruct/structures/fem.py b/openaerostruct/structures/fem.py
index bb7c42fbd..2f3323194 100644
--- a/openaerostruct/structures/fem.py
+++ b/openaerostruct/structures/fem.py
@@ -7,7 +7,7 @@
 import openmdao.api as om
 
 
-def get_drdu_sparsity_pattern(ny, vec_size, symmetry, root_BC_pin=False):
+def get_drdu_sparsity_pattern(ny, vec_size, symmetry, root_BC="rigid"):
     """
     return sparsity pattern of partials of residuals w.r.t. displacements = stiffness matrix
     """
@@ -47,12 +47,20 @@ def get_drdu_sparsity_pattern(ny, vec_size, symmetry, root_BC_pin=False):
     num_dofs = 6 * ny
 
     # Fixed boundary condition. Number of additional "DoFs" varies depending on the root boundary condition type.
-    if root_BC_pin:
-        arange = np.arange(3)  # translation only
+    if root_BC == "rigid":  # translation and rotation
+        row_arange = np.arange(6)
+        col_arange = np.arange(6)
+    elif root_BC == "pin":  # translation and rotation in y and z
+        row_arange = np.array([0, 1, 2, 4, 5])  # exclude rotation in x
+        col_arange = np.arange(5)
+    elif root_BC == "ball":  # translation only
+        row_arange = np.arange(3)
+        col_arange = np.arange(3)
     else:
-        arange = np.arange(6)  # translation and rotation
-    rows6 = index + arange
-    cols6 = num_dofs + arange
+        raise ValueError(f"Invalid root boundary condition type: {root_BC}")
+
+    rows6 = index + row_arange
+    cols6 = num_dofs + col_arange
 
     rows = np.concatenate([rows1, rows2, rows3, rows4, rows5, rows6, cols6])
     cols = np.concatenate([cols1, cols2, cols3, cols4, cols5, cols6, rows6])
diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 9a954f454..817d68ee1 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -10,7 +10,6 @@
 
 # TODO:
 # - implement ball and pin joint (current pin joint should be renamed to ball)
-# - implement pin/ball joint for the root symmetric boundary
 
 
 class FEMStrutBraced(om.ImplicitComponent):
@@ -90,15 +89,20 @@ def setup(self):
 
             # --- inputs, outputs, partials of FEM system for each surface ---
             ny = surface["mesh"].shape[1]
-            if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
-                # pin boundary condition at the root
-                size = int(6 * ny + 3)
-                root_BC_pin = True
+            if "root_BC_type" in surface and surface["root_BC_type"] == "ball":
+                # ball boundary condition at the root. Constrain translation only.
+                dof_of_boundary = 3
+                root_BC = "ball"
+            elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+                # pin boundary condition at the root. Constrain translation and rotation in y and z.
+                dof_of_boundary = 5
+                root_BC = "pin"
             else:
-                # rigid boundary condition at the root
-                size = int(6 * ny + 6)
-                root_BC_pin = False
+                # rigid boundary condition at the root. Constrain translation and rotation.
+                dof_of_boundary = 6
+                root_BC = "rigid"
             self.ny.append(ny)
+            size = int(6 * ny + dof_of_boundary)
             self.size.append(size)
             
             full_size = size * vec_size
@@ -114,7 +118,7 @@ def setup(self):
 
             # The derivative of residual wrt displacements is the stiffness matrix K. We can use the
             # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
-            rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"], root_BC_pin)
+            rows, cols, vec_rows, vec_cols = get_drdu_sparsity_pattern(ny, vec_size, surface["symmetry"], root_BC)
             if i == 1:
                 # the second surface (strut) goes to the lower-right block of the entire stiffness matrix
                 rows += self.size[0]
@@ -343,9 +347,12 @@ def assemble_CSC_K(self, inputs):
             data5 = (k_loc[0:-1, 6:, 6:] + k_loc[1:, :6, :6]).flatten()
 
             # data6 corresponds to the root boundary condition
-            if "root_BC_type" in surface and surface["root_BC_type"] == "pin":
-                # for pin BC (constraint translation only)
+            if "root_BC_type" in surface and surface["root_BC_type"] == "ball":
+                # for ball BC (constraint translation only)
                 data6 = np.full((3,), 1e9)
+            elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
+                # for pin BC (constraint translation and rotation in y and z)
+                data6 = np.full((5,), 1e9)
             else:
                 # for rigid BC (constraint translation and rotation)
                 data6 = np.full((6,), 1e9)

From e400ce5f396bcb0e275cb1d298fe194baa82847f Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 16 Jul 2025 19:35:58 -0400
Subject: [PATCH 09/30] added pin joint; renamed previous  joint to ball joint

---
 openaerostruct/structures/fem_strut_braced.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 817d68ee1..2b152d23e 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -8,9 +8,6 @@
 
 from .fem import get_drdu_sparsity_pattern, get_drdK_sparsity_pattern
 
-# TODO:
-# - implement ball and pin joint (current pin joint should be renamed to ball)
-
 
 class FEMStrutBraced(om.ImplicitComponent):
     """
@@ -133,10 +130,12 @@ def setup(self):
 
         # --- joint constraints (coupling terms between two surfaces) ---
         joint_type = self.surfaces[0]["joint_type"]
-        if joint_type == 'pin':
+        if joint_type == 'ball':
             self.n_con = n_con = 3   # number of joint constraints: translational only
+        elif joint_type == 'pin':
+            self.n_con = n_con = 5   # translational and rotational in y and z
         elif joint_type == 'rigid':
-            self.n_con = n_con = 6   # number of joint constraints: translational and rotational
+            self.n_con = n_con = 6   # ranslational and rotational in x, y, and z
         else:
             raise ValueError("Joint type must be either 'pin' or 'rigid'.")
 
@@ -163,7 +162,10 @@ def setup(self):
 
             # partials of joint constraint residuals w.r.t. displacement
             rows = np.arange(n_con)
-            cols = np.arange(n_con) + 6 * joint_idx
+            if joint_type in ['ball', 'rigid']:
+                cols = np.arange(n_con) + 6 * joint_idx
+            elif joint_type == 'pin':
+                cols = np.array([0, 1, 2, 4, 5]) + 6 * joint_idx  # exclude x-rotation
             if i == 0:
                 vals = np.ones(n_con) * 1e9
             else:

From 42d5a053d53b0b516ca7916a541c7f0f4ec28ec3 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 16 Jul 2025 21:22:50 -0400
Subject: [PATCH 10/30] fixed Euler buckling derivative

---
 openaerostruct/structures/failure_buckling_ks.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
index ef68e0c92..881dbdb83 100644
--- a/openaerostruct/structures/failure_buckling_ks.py
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -185,9 +185,6 @@ def compute(self, inputs, outputs):
         joint_load = inputs["joint_load"]
         Iz = inputs["Iz"]
 
-        # convert joint load to N (FEM normalizes this by 1e9, so we apply it back)
-        joint_load *= 1e9
-
         # strut length
         # The length we compute from the FEM nodes are longer than the actual length because e.g. we don't model fuselage so the strut root is at the symmetry plane.
         # To account for this, apply a factor < 1 to the strut length.
@@ -197,7 +194,8 @@ def compute(self, inputs, outputs):
         # compression load
         strut_direction = (nodes[-1, :] - nodes[0, :])
         strut_direction /= np.linalg.norm(strut_direction)  # unit magniture
-        comp_load = np.dot(joint_load, strut_direction)  # flip sign to make compression = positive
+        # multiply by 1e9 to make the units to N (FEM normalizes this by 1e9)
+        comp_load = np.dot(joint_load, strut_direction) * 1e9
         
         # critical load with safety factor of 1.5
         sf = 1.5

From 114193007e6c829cf8b904c668caa79f215c85b7 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 30 Jul 2025 17:10:11 -0400
Subject: [PATCH 11/30] refactored wing-strut joint definitions

---
 .../integration/aerostruct_groups.py          | 11 +--
 openaerostruct/structures/fem_strut_braced.py | 72 +++++++++++++------
 .../structures/spatial_beam_functionals.py    | 20 +++---
 openaerostruct/structures/vonmises_wingbox.py |  4 +-
 4 files changed, 70 insertions(+), 37 deletions(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index a9bf12f43..040f62228 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -185,13 +185,14 @@ def setup(self):
         elif surface["fem_model_type"] == "wingbox":
             promotes_inputs = ["Qz", "J", "A_enc", "spar_thickness", "htop", "hbottom", "hfront", "hrear", "nodes", "disp"]
             promotes_outputs = ["vonmises", "failure"]
-            if "buckling" in surface and surface["buckling"]:
+
+            # additional inputs/outputs for buckling
+            if "panel_buckling" in surface and surface["panel_buckling"]:
                 promotes_inputs += ["skin_thickness", "t_over_c", "fem_chords"]
                 promotes_outputs += ["failure_local_buckling"]
-                if surface["name"] == "strut":
-                    # additional inputs/outputs for column buckling
-                    promotes_inputs += ["Iz", "joint_load"]
-                    promotes_outputs += ["failure_column_buckling"]
+            if "column_buckling" in surface and surface["column_buckling"]:
+                promotes_inputs += ["Iz", "joint_load"]
+                promotes_outputs += ["failure_column_buckling"]
 
             self.add_subsystem(
                 "struct_funcs",
diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 2b152d23e..97e1605c5 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -68,11 +68,52 @@ def setup(self):
         """
         Matrix and RHS are inputs, solution vector is the output.
         """
+        # --- input option check and processings ---
         vec_size = self.options["vec_size"]
         self.surfaces = self.options["surfaces"]
-        if len(self.surfaces) != 2:
-            raise ValueError("FEMStrutBraced component requires exactly two surfaces (wing and strut).")
-        self.surface_names = [self.surfaces[0]["name"], self.surfaces[1]["name"]]
+        self.surface_names = [surface["name"] for surface in self.surfaces]
+
+        # surfaces must be either [wing, strut] or [wing, strut, jury] in this order
+        if len(self.surfaces) == 2:
+            if self.surface_names != ["wing", "strut"]:
+                raise ValueError("FEMStrutBraced component requires the surfaces to be in the order of [wing, strut].")
+            include_jury = False
+            self.wing_surface = self.surfaces[0]
+            self.strut_surface = self.surfaces[1]
+        elif len(self.surfaces) == 3:
+            if self.surface_names != ["wing", "strut", "jury"]:
+                raise ValueError("FEMStrutBraced component requires the surfaces to be in the order of [wing, strut, jury].")
+            include_jury = True
+            self.wing_surface = self.surfaces[0]
+            self.strut_surface = self.surfaces[1]
+            self.jury_surface = self.surfaces[2]
+        else:
+            raise ValueError("FEMStrutBraced component requires exactly two or three surfaces (wing, strut, and/or jury).")
+
+        # no support for asymmetric surfaces
+        for surface in self.surfaces:
+            if not surface["symmetry"]:
+                raise NotImplementedError("Strut-braced wing joint is only implemented for symmetric surfaces.")
+
+        # We only support the surface name to be "wing" and "strut", and "jury" for now
+        for surface in self.surfaces:
+            if surface["name"] not in ["wing", "strut", "jury"]:
+                raise ValueError("FEMStrutBraced component does not support surface name: " + surface["name"])
+
+        # get joint information
+        wing_strut_joint_type = self.strut_surface["wing_strut_joint_type"]
+        wing_strut_joint_y = self.strut_surface["wing_strut_joint_y"]
+        # check sign convention for y (spanwise coordinate)
+        if wing_strut_joint_y * self.wing_surface["mesh"][0, 0, 1] < 0:
+            wing_strut_joint_y *= -1
+
+        if include_jury:
+            wing_jury_joint_type = self.jury_surface["wing_strut_joint_type"]
+            wing_jury_joint_y = self.jury_surface["wing_strut_joint_y"]
+            strut_jury_joint_type = self.jury_surface["strut_joint_type"]
+            strut_jury_joint_y = self.jury_surface["strut_joint_y"]
+
+        # prepare inputs
         self.ny = []  # number of spanwise nodes
         self.size = []   # size of assembled K matrix for each surface
         self.num_k_data = []  # number of non-zero entries for assembled K matrix for each surface
@@ -128,13 +169,12 @@ def setup(self):
             rows, cols = get_drdK_sparsity_pattern(ny)
             self.declare_partials(f"disp_aug_{name}", f"local_stiff_transformed_{name}", rows=rows, cols=cols)
 
-        # --- joint constraints (coupling terms between two surfaces) ---
-        joint_type = self.surfaces[0]["joint_type"]
-        if joint_type == 'ball':
+        # --- wing-strut joint constraints (coupling terms between two surfaces) ---
+        if wing_strut_joint_type == 'ball':
             self.n_con = n_con = 3   # number of joint constraints: translational only
-        elif joint_type == 'pin':
+        elif wing_strut_joint_type == 'pin':
             self.n_con = n_con = 5   # translational and rotational in y and z
-        elif joint_type == 'rigid':
+        elif wing_strut_joint_type == 'rigid':
             self.n_con = n_con = 6   # ranslational and rotational in x, y, and z
         else:
             raise ValueError("Joint type must be either 'pin' or 'rigid'.")
@@ -145,26 +185,18 @@ def setup(self):
         k_rows_joint = []
         k_cols_joint = []
         self.k_data_joint = []
-        for i, surface in enumerate(self.surfaces):
+        for i, surface in enumerate([self.wing_surface, self.strut_surface]):
             name = surface["name"]
 
-            # find the node index for the joint
-            joint_y = surface["joint_y"]
-            if not surface["symmetry"]:
-                raise NotImplementedError("Strut-braced wing joint is only implemented for symmetric surfaces.")
-            # check sign convention for y (spanwise coordinate)
-            if joint_y * surface["mesh"][0, 0, 1] < 0:
-                joint_y *= -1
-
-            joint_idx = np.argmin(np.abs(surface["mesh"][0, :, 1] - joint_y))
+            joint_idx = np.argmin(np.abs(surface["mesh"][0, :, 1] - wing_strut_joint_y))
             joint_indices.append(joint_idx)
             print("Surface", name, "joint y:", surface["mesh"][0, joint_idx, 1], "joint index:", joint_idx)
 
             # partials of joint constraint residuals w.r.t. displacement
             rows = np.arange(n_con)
-            if joint_type in ['ball', 'rigid']:
+            if wing_strut_joint_type in ['ball', 'rigid']:
                 cols = np.arange(n_con) + 6 * joint_idx
-            elif joint_type == 'pin':
+            elif wing_strut_joint_type == 'pin':
                 cols = np.array([0, 1, 2, 4, 5]) + 6 * joint_idx  # exclude x-rotation
             if i == 0:
                 vals = np.ones(n_con) * 1e9
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index 212b88423..705ad5163 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -76,8 +76,8 @@ def setup(self):
                 "failure", FailureKS(surface=surface), promotes_inputs=["vonmises"], promotes_outputs=["failure"]
             )
 
-        # compute buckling failure
-        if "buckling" in surface and surface["buckling"]:
+        # compute panel local buckling failure
+        if "panel_buckling" in surface and surface["panel_buckling"]:
             # skin panel buckling and spar shear buckling
             self.add_subsystem(
                 "local_buckling",
@@ -90,11 +90,11 @@ def setup(self):
             self.connect("vonmises.front_spar_shear_stress", "local_buckling.front_spar_shear_stress")
             self.connect("vonmises.rear_spar_shear_stress", "local_buckling.rear_spar_shear_stress")
 
-            # global Euler column buckling
-            if surface["name"] == "strut":
-                self.add_subsystem(
-                    "column_buckling",
-                    EulerColumnBucklingFailureKS(surface=surface),
-                    promotes_inputs=["nodes", "joint_load", "Iz"],
-                    promotes_outputs=["failure_column_buckling"]
-                )
+        # global Euler column buckling
+        if "column_buckling" in surface and surface["column_buckling"]:
+            self.add_subsystem(
+                "column_buckling",
+                EulerColumnBucklingFailureKS(surface=surface),
+                promotes_inputs=["nodes", "joint_load", "Iz"],
+                promotes_outputs=["failure_column_buckling"]
+            )
diff --git a/openaerostruct/structures/vonmises_wingbox.py b/openaerostruct/structures/vonmises_wingbox.py
index 115e6e404..68b80dfac 100644
--- a/openaerostruct/structures/vonmises_wingbox.py
+++ b/openaerostruct/structures/vonmises_wingbox.py
@@ -79,7 +79,7 @@ def setup(self):
         self.add_output("vonmises", val=np.zeros((self.ny - 1, 4)), units="N/m**2")
 
         # also output upper skin's compression stress and spar shear stress for buckling
-        if "buckling" in self.surface and self.surface["buckling"]:
+        if "panel_buckling" in self.surface and self.surface["panel_buckling"]:
             # positive = compression
             self.add_output("upper_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
             self.add_output("lower_skin_comp_stress", val=np.zeros(self.ny - 1), units="N/m**2")
@@ -186,7 +186,7 @@ def compute(self, inputs, outputs):
             )
 
             # compute upper skin's compression stress and spar shear stress for buckling failure check
-            if "buckling" in self.surface and self.surface["buckling"]:
+            if "panel_buckling" in self.surface and self.surface["panel_buckling"]:
                 # flip sign to let positive = compression
                 outputs["upper_skin_comp_stress"][ielem] = -(axial_stress + top_bending_stress)
                 outputs["lower_skin_comp_stress"][ielem] = -(axial_stress + bottom_bending_stress)

From b4f8ef089cec0051b3f70591fa5368c25cedb2ed Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Thu, 31 Jul 2025 20:12:11 -0400
Subject: [PATCH 12/30] working on jury strut, code runs but results seem wrong

---
 .../functionals/total_performance.py          |  32 +-
 .../integration/aerostruct_groups.py          |  60 +++-
 openaerostruct/structures/create_rhs.py       |   2 +
 openaerostruct/structures/disp.py             |   2 +
 openaerostruct/structures/fem.py              |   3 +
 openaerostruct/structures/fem_strut_braced.py | 285 ++++++++++++++----
 .../structures/spatial_beam_states.py         |  13 +
 7 files changed, 318 insertions(+), 79 deletions(-)

diff --git a/openaerostruct/functionals/total_performance.py b/openaerostruct/functionals/total_performance.py
index 4145a0cee..d14b0e7e8 100644
--- a/openaerostruct/functionals/total_performance.py
+++ b/openaerostruct/functionals/total_performance.py
@@ -17,13 +17,33 @@ def initialize(self):
         self.options.declare("surfaces", types=list)
         self.options.declare("user_specified_Sref", types=bool)
         self.options.declare("internally_connect_fuelburn", types=bool, default=True)
+        self.options.declare("strut_braced", default=False, types=bool)
 
     def setup(self):
         surfaces = self.options["surfaces"]
 
+        if self.options["strut_braced"]:
+            if len(surfaces) == 2:
+                # wing + strut. Make sure that the given surfaces are in order
+                if surfaces[0]["name"] == "wing" and surfaces[1]["name"] == "strut":
+                    surfaces_all = surfaces
+                    surfaces_AS = surfaces
+                    pass
+                else:
+                    raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+            elif len(surfaces) == 3:
+                # wing + strut + jury
+                if surfaces[0]["name"] == "wing" and surfaces[1]["name"] == "strut" and surfaces[2]["name"] == "jury":
+                    surfaces_all = surfaces
+                    surfaces_AS = [surfaces[0], surfaces[1]]   # exclude jury from VLM
+                else:
+                    raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+            else:
+                raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+
         if not self.options["user_specified_Sref"]:
             self.add_subsystem(
-                "sum_areas", SumAreas(surfaces=surfaces), promotes_inputs=["*S_ref"], promotes_outputs=["S_ref_total"]
+                "sum_areas", SumAreas(surfaces=surfaces_AS), promotes_inputs=["*S_ref"], promotes_outputs=["S_ref_total"]
             )
 
         if self.options["internally_connect_fuelburn"]:
@@ -33,21 +53,21 @@ def setup(self):
 
         self.add_subsystem(
             "CL_CD",
-            TotalLiftDrag(surfaces=surfaces),
+            TotalLiftDrag(surfaces=surfaces_AS),
             promotes_inputs=["*CL", "*CD", "*S_ref", "S_ref_total", "rho", "v"],
             promotes_outputs=["CL", "CD", "L", "D"],
         )
 
         self.add_subsystem(
             "fuelburn",
-            BreguetRange(surfaces=surfaces),
+            BreguetRange(surfaces=surfaces_all),
             promotes_inputs=["*structural_mass", "CL", "CD", "CT", "speed_of_sound", "R", "Mach_number", "W0"],
             promotes_outputs=["fuelburn"],
         )
 
         self.add_subsystem(
             "L_equals_W",
-            Equilibrium(surfaces=surfaces),
+            Equilibrium(surfaces=surfaces_all),
             promotes_inputs=["CL", "*structural_mass", "S_ref_total", "W0", "load_factor", "rho", "v"]
             + promote_fuelburn,
             promotes_outputs=["L_equals_W", "total_weight"],
@@ -55,7 +75,7 @@ def setup(self):
 
         self.add_subsystem(
             "CG",
-            CenterOfGravity(surfaces=surfaces),
+            CenterOfGravity(surfaces=surfaces_all),
             promotes_inputs=["*structural_mass", "*cg_location", "total_weight", "W0", "empty_cg", "load_factor"]
             + promote_fuelburn,
             promotes_outputs=["cg"],
@@ -63,7 +83,7 @@ def setup(self):
 
         self.add_subsystem(
             "moment",
-            MomentCoefficient(surfaces=surfaces),
+            MomentCoefficient(surfaces=surfaces_AS),
             promotes_inputs=["v", "rho", "cg", "S_ref_total", "*b_pts", "*widths", "*chords", "*sec_forces", "*S_ref"],
             promotes_outputs=["CM"],
         )
diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 040f62228..8ecd2f1f6 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -227,17 +227,48 @@ def setup(self):
         coupled = om.Group()
 
         if self.options["strut_braced"]:
-            if len(surfaces) != 2:
-                raise NameError("Strut-braced wing requires exactly two surfaces.")
-            # add FEM directly under the coupled group because multiple surfaces are coupled in the FEM level
+            if len(surfaces) == 2:
+                # wing + strut. Make sure that the given surfaces are in order
+                if surfaces[0]["name"] == "wing" and surfaces[1]["name"] == "strut":
+                    surfaces_all = surfaces
+                    surfaces_AS = surfaces
+                    pass
+                else:
+                    raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+            elif len(surfaces) == 3:
+                # wing + strut + jury
+                if surfaces[0]["name"] == "wing" and surfaces[1]["name"] == "strut" and surfaces[2]["name"] == "jury":
+                    surfaces_all = surfaces
+                    surfaces_AS = [surfaces[0], surfaces[1]]   # exclude jury from VLM
+                    pass
+                else:
+                    raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+
+                # disable jury strut root boundary condition
+                surfaces[2]["root_BC_type"] = "none"
+                surfaces_all[2]["root_BC_type"] = "none"
+
+            # add coupled FEM group
             coupled.add_subsystem(
                 "FEM_SBW",
-                SpatialBeamStates(surface=surfaces, strut_braced=True),
+                SpatialBeamStates(surface=surfaces_all, strut_braced=True),
                 promotes_inputs=["*"],
                 promotes_outputs=["disp_*"]
             )
+        else:
+            surfaces_all = surfaces
+            surfaces_AS = surfaces
 
-        for surface in surfaces:
+        # connections for all structural components
+        for surface in surfaces_all:
+            name = surface["name"]
+
+            # connect displacements to the performance group
+            disp_source = f"coupled.disp_{name}" if self.options["strut_braced"] else f"coupled.{name}.disp"
+            self.connect(disp_source, name + "_perf.disp")
+
+        # connections for all aerostructural surfaces
+        for surface in surfaces_AS:
             name = surface["name"]
 
             # Connect the output of the loads component with the FEM
@@ -270,8 +301,6 @@ def setup(self):
 
             # Connect parameters from the 'coupled' group to the performance
             # groups for the individual surfaces.
-            disp_source = f"coupled.disp_{name}" if self.options["strut_braced"] else f"coupled.{name}.disp"
-            self.connect(disp_source, name + "_perf.disp")
             self.connect("coupled." + name + ".S_ref", name + "_perf.S_ref")
             self.connect("coupled." + name + ".widths", name + "_perf.widths")
             # self.connect('coupled.' + name + '.chords', name + '_perf.chords')
@@ -308,10 +337,10 @@ def setup(self):
                 ground_effect = True
 
         if self.options["compressible"] is True:
-            aero_states = CompressibleVLMStates(surfaces=surfaces, rotational=rotational)
+            aero_states = CompressibleVLMStates(surfaces=surfaces_AS, rotational=rotational)
             prom_in = ["v", "alpha", "beta", "rho", "Mach_number"]
         else:
-            aero_states = VLMStates(surfaces=surfaces, rotational=rotational)
+            aero_states = VLMStates(surfaces=surfaces_AS, rotational=rotational)
             prom_in = ["v", "alpha", "beta", "rho"]
         if ground_effect:
             prom_in.append("height_agl")
@@ -322,7 +351,7 @@ def setup(self):
 
         # Explicitly connect parameters from each surface's group and the common
         # 'aero_states' group.
-        for surface in surfaces:
+        for surface in surfaces_AS:
             name = surface["name"]
 
             # Add a loads component to the coupled group
@@ -363,7 +392,8 @@ def setup(self):
         # Add the coupled group to the model problem
         self.add_subsystem("coupled", coupled, promotes_inputs=prom_in)
 
-        for surface in surfaces:
+        # post-AS-analysis computations for aerostructural surfaces
+        for surface in surfaces_AS:
             name = surface["name"]
 
             # Add a performance group which evaluates the data after solving
@@ -374,6 +404,13 @@ def setup(self):
                 name + "_perf", perf_group, promotes_inputs=["rho", "v", "alpha", "beta", "re", "Mach_number"]
             )
 
+        # post-AS-analysis computations for structure-only components
+        for surface in [s for s in surfaces_all if s not in surfaces_AS]:
+            self.add_subsystem(
+                f"{surface["name"]}_perf",
+                SpatialBeamFunctionals(surface=surface),
+            )
+
         # Add functionals to evaluate performance of the system.
         # Note that only the interesting results are promoted here; not all
         # of the parameters.
@@ -381,6 +418,7 @@ def setup(self):
             "total_perf",
             TotalPerformance(
                 surfaces=surfaces,
+                strut_braced=self.options["strut_braced"],
                 user_specified_Sref=self.options["user_specified_Sref"],
                 internally_connect_fuelburn=self.options["internally_connect_fuelburn"],
             ),
diff --git a/openaerostruct/structures/create_rhs.py b/openaerostruct/structures/create_rhs.py
index 20bc56492..52ced83eb 100644
--- a/openaerostruct/structures/create_rhs.py
+++ b/openaerostruct/structures/create_rhs.py
@@ -37,6 +37,8 @@ def setup(self):
             dof_of_boundary = 3  # translation only
         elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
             dof_of_boundary = 5  # translation and rotation in y and z
+        elif "root_BC_type" in surface and surface["root_BC_type"] == "none":
+            dof_of_boundary = 0  # no boundary conditions (for jury strut)
         else:
             dof_of_boundary = 6  # translation and rotation
         self.add_output("forces", val=np.ones((self.ny * 6 + dof_of_boundary)), units="N")
diff --git a/openaerostruct/structures/disp.py b/openaerostruct/structures/disp.py
index 44bc0f27f..60f1052ec 100644
--- a/openaerostruct/structures/disp.py
+++ b/openaerostruct/structures/disp.py
@@ -40,6 +40,8 @@ def setup(self):
             dof_of_boundary = 3  # translation only
         elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
             dof_of_boundary = 5  # translation and rotation in y and z
+        elif "root_BC_type" in surface and surface["root_BC_type"] == "none":
+            dof_of_boundary = 0  # no boundary conditions (for jury strut)
         else:
             dof_of_boundary = 6  # translation and rotation
         self.add_input("disp_aug", val=np.zeros((self.ny * 6 + dof_of_boundary)), units="m")
diff --git a/openaerostruct/structures/fem.py b/openaerostruct/structures/fem.py
index 2f3323194..74d884ba8 100644
--- a/openaerostruct/structures/fem.py
+++ b/openaerostruct/structures/fem.py
@@ -56,6 +56,9 @@ def get_drdu_sparsity_pattern(ny, vec_size, symmetry, root_BC="rigid"):
     elif root_BC == "ball":  # translation only
         row_arange = np.arange(3)
         col_arange = np.arange(3)
+    elif root_BC == "none":  # no root BC (e.g. for jury strut)
+        row_arange = np.array([])
+        col_arange = np.array([])
     else:
         raise ValueError(f"Invalid root boundary condition type: {root_BC}")
 
diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 97e1605c5..628cdf698 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -9,6 +9,46 @@
 from .fem import get_drdu_sparsity_pattern, get_drdK_sparsity_pattern
 
 
+def _get_joint_size(joint_type):
+    """
+    Return the number of joint constraints for a given joint type.
+    """
+    if joint_type == 'ball':
+        n_con = 3   # number of joint constraints: translational only
+    elif joint_type == 'pin':
+        n_con = 5   # translational and rotational in y and z
+    elif joint_type == 'rigid':
+        n_con = 6   # ranslational and rotational in x, y, and z
+    else:
+        raise ValueError("Joint type must be either 'pin' or 'rigid'.")
+    return n_con
+
+def _get_joint_idx_from_y(surface, joint_y):
+    """
+    Return the joint index from the joint y (spanwise) coordinate.
+    This is only good for wing or strut, but do not use for jury (or any vertical surface)
+    """
+    if surface["name"] == "jury":
+        raise RuntimeError("Cannot use _get_joint_idx_from_y for jury surface.")
+    joint_idx = np.argmin((np.abs(surface["mesh"][0, :, 1]) - abs(joint_y))**2)
+    return joint_idx
+
+def _joint_rows_cols(joint_type, surface, joint_idx):
+    """
+    Return rows and cols indices for joint constraints.
+    rows and cols are defined for the component-level indexing, but not the global wing-strut-jury system.
+    """
+    # partials of joint constraint residuals w.r.t. displacement
+    n_con = _get_joint_size(joint_type)
+    rows = np.arange(n_con)
+    if joint_type in ['ball', 'rigid']:
+        cols = np.arange(n_con) + 6 * joint_idx
+    elif joint_type == 'pin':
+        cols = np.array([0, 1, 2, 4, 5]) + 6 * joint_idx  # exclude x-rotation
+
+    return rows, cols
+
+
 class FEMStrutBraced(om.ImplicitComponent):
     """
     Component that solves an FEM linear system, K u = f.
@@ -77,13 +117,13 @@ def setup(self):
         if len(self.surfaces) == 2:
             if self.surface_names != ["wing", "strut"]:
                 raise ValueError("FEMStrutBraced component requires the surfaces to be in the order of [wing, strut].")
-            include_jury = False
+            self.include_jury = False
             self.wing_surface = self.surfaces[0]
             self.strut_surface = self.surfaces[1]
         elif len(self.surfaces) == 3:
             if self.surface_names != ["wing", "strut", "jury"]:
                 raise ValueError("FEMStrutBraced component requires the surfaces to be in the order of [wing, strut, jury].")
-            include_jury = True
+            self.include_jury = True
             self.wing_surface = self.surfaces[0]
             self.strut_surface = self.surfaces[1]
             self.jury_surface = self.surfaces[2]
@@ -103,24 +143,20 @@ def setup(self):
         # get joint information
         wing_strut_joint_type = self.strut_surface["wing_strut_joint_type"]
         wing_strut_joint_y = self.strut_surface["wing_strut_joint_y"]
-        # check sign convention for y (spanwise coordinate)
-        if wing_strut_joint_y * self.wing_surface["mesh"][0, 0, 1] < 0:
-            wing_strut_joint_y *= -1
 
-        if include_jury:
-            wing_jury_joint_type = self.jury_surface["wing_strut_joint_type"]
-            wing_jury_joint_y = self.jury_surface["wing_strut_joint_y"]
-            strut_jury_joint_type = self.jury_surface["strut_joint_type"]
-            strut_jury_joint_y = self.jury_surface["strut_joint_y"]
+        if self.include_jury:
+            wing_jury_joint_type = self.jury_surface["wing_jury_joint_type"]
+            wing_jury_joint_y = self.jury_surface["wing_jury_joint_y"]
+            strut_jury_joint_type = self.jury_surface["strut_jury_joint_type"]
+            strut_jury_joint_y = self.jury_surface["strut_jury_joint_y"]
 
         # prepare inputs
         self.ny = []  # number of spanwise nodes
-        self.size = []   # size of assembled K matrix for each surface
+        self.size = []   # list of size (num rows) of assembled K matrix for each surface
         self.num_k_data = []  # number of non-zero entries for assembled K matrix for each surface
         self._lup = []
         k_cols = []  # column indices for stiffness matrix sparsity pattern
         k_rows = []  # row indices for stiffness matrix sparsity pattern
-        joint_indices = []   # node index for the joint between wing and strut
 
         for i, surface in enumerate(self.surfaces):
             name = surface["name"]
@@ -135,6 +171,10 @@ def setup(self):
                 # pin boundary condition at the root. Constrain translation and rotation in y and z.
                 dof_of_boundary = 5
                 root_BC = "pin"
+            elif "root_BC_type" in surface and surface["root_BC_type"] == "none":
+                # no root boundary conditions for jury strut
+                dof_of_boundary = 0
+                root_BC = "none"
             else:
                 # rigid boundary condition at the root. Constrain translation and rotation.
                 dof_of_boundary = 6
@@ -170,61 +210,160 @@ def setup(self):
             self.declare_partials(f"disp_aug_{name}", f"local_stiff_transformed_{name}", rows=rows, cols=cols)
 
         # --- wing-strut joint constraints (coupling terms between two surfaces) ---
-        if wing_strut_joint_type == 'ball':
-            self.n_con = n_con = 3   # number of joint constraints: translational only
-        elif wing_strut_joint_type == 'pin':
-            self.n_con = n_con = 5   # translational and rotational in y and z
-        elif wing_strut_joint_type == 'rigid':
-            self.n_con = n_con = 6   # ranslational and rotational in x, y, and z
-        else:
-            raise ValueError("Joint type must be either 'pin' or 'rigid'.")
+        # list of all joing Lagrange multipliers (will use later)
+        self.joint_list = []
+        # number of joint constraints
+        self.n_con = 0  # total number of joint constraints (wing-strut + wing-jury + strut-jury)
+        n_con_ws = self.n_con_ws = _get_joint_size(wing_strut_joint_type)
+        self.n_con += n_con_ws
 
         # add Lagrange multipliers for joint constraints as state variables
-        self.add_output("joint_Lag", shape=(n_con,), val=0.0)
+        self.add_output("joint_Lag_wing_strut", shape=(n_con_ws,), val=0.0)
+        self.joint_list.append("wing_strut")
 
-        k_rows_joint = []
-        k_cols_joint = []
-        self.k_data_joint = []
+        k_rows_joint_ws = []
+        k_cols_joint_ws = []
+        self.k_data_joint = []  # for all joints (wing-strut, wing-jury, strut-jury)
         for i, surface in enumerate([self.wing_surface, self.strut_surface]):
             name = surface["name"]
 
-            joint_idx = np.argmin(np.abs(surface["mesh"][0, :, 1] - wing_strut_joint_y))
-            joint_indices.append(joint_idx)
-            print("Surface", name, "joint y:", surface["mesh"][0, joint_idx, 1], "joint index:", joint_idx)
-
             # partials of joint constraint residuals w.r.t. displacement
-            rows = np.arange(n_con)
-            if wing_strut_joint_type in ['ball', 'rigid']:
-                cols = np.arange(n_con) + 6 * joint_idx
-            elif wing_strut_joint_type == 'pin':
-                cols = np.array([0, 1, 2, 4, 5]) + 6 * joint_idx  # exclude x-rotation
+            joint_idx = _get_joint_idx_from_y(surface, wing_strut_joint_y)
+            print(f'Wing-strut joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+            rows, cols = _joint_rows_cols(wing_strut_joint_type, surface, joint_idx)
             if i == 0:
-                vals = np.ones(n_con) * 1e9
+                vals = np.ones(n_con_ws) * 1e9
             else:
-                vals = np.ones(n_con) * -1e9
-            self.declare_partials("joint_Lag", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+                vals = np.ones(n_con_ws) * -1e9
+            self.declare_partials("joint_Lag_wing_strut", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
 
             # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
-            self.declare_partials(f"disp_aug_{name}", "joint_Lag", rows=cols, cols=rows, val=vals)
+            self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_strut", rows=cols, cols=rows, val=vals)
 
-            # append these entries to the bottom and right of the entire K matrix
-            rows += self.size[0] + self.size[1]
-            if i == 1:
+            # rows/cols in the global K matrix (bottom of the matrix)
+            rows += sum(self.size)
+            if name == "strut":
                 cols += self.size[0]
 
-            # partials of joint constraint residuals w.r.t. local stiffness matrix
-            k_rows_joint.append(rows)
-            k_cols_joint.append(cols)
+            # append these entries to the bottom of the global K matrix and its transpose
+            k_rows_joint_ws.append(rows)
+            k_cols_joint_ws.append(cols)
             self.k_data_joint.append(vals)
-            # partials of FEM residuals wrt joint Lagrange multipliers
-            k_rows_joint.append(cols)
-            k_cols_joint.append(rows)
+            k_rows_joint_ws.append(cols)
+            k_cols_joint_ws.append(rows)
             self.k_data_joint.append(vals)
 
-        # row and col indices for the entire stiffness matrix (that combines wing, strut, and joint constraints)
-        self.k_cols = np.concatenate(k_cols + k_cols_joint)
-        self.k_rows = np.concatenate(k_rows + k_rows_joint)
-        self.total_size = sum(self.size) + n_con   # size of total stiffness matrix (wing + strut + constraints)
+            print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
+
+        # row and col indices for the entire stiffness matrix (that combines wing, strut, (jury), and joint constraints)
+        self.k_cols = np.concatenate(k_cols + k_cols_joint_ws)
+        self.k_rows = np.concatenate(k_rows + k_rows_joint_ws)
+        self.total_size = sum(self.size) + n_con_ws   # size (num rows) of total stiffness matrix (K matrices + joint constraints)
+
+        print('wing-strut joint added, total_size', self.total_size, '\n')
+
+        if self.include_jury:
+            # --- wing-jury joint constraints ---
+            n_con_wj = self.n_con_wj = _get_joint_size(wing_jury_joint_type)
+            self.n_con += n_con_wj
+
+            # add Lagrange multipliers for joint constraints as state variables
+            self.add_output("joint_Lag_wing_jury", shape=(n_con_wj,), val=0.0)
+            self.joint_list.append("wing_jury")
+
+            k_rows_joint_wj = []
+            k_cols_joint_wj = []
+            for i, surface in enumerate([self.wing_surface, self.jury_surface]):
+                name = surface["name"]
+
+                # partials of joint constraint residuals w.r.t. displacement
+                if name == "wing":
+                    joint_idx = _get_joint_idx_from_y(surface, wing_jury_joint_y)
+                elif name == "jury":
+                    joint_idx = 0  # jury index starts from 0 at the wing-jury joint
+                print(f'Wing-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+                rows, cols = _joint_rows_cols(wing_jury_joint_type, surface, joint_idx)
+                if i == 0:
+                    vals = np.ones(n_con_wj) * 1e9
+                else:
+                    vals = np.ones(n_con_wj) * -1e9
+                self.declare_partials("joint_Lag_wing_jury", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+
+                # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
+                self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_jury", rows=cols, cols=rows, val=vals)
+
+                # append these entries to the global K matrix
+                rows += self.total_size
+                if name == "jury":
+                    cols += self.size[0] + self.size[1]
+
+                print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
+
+                k_rows_joint_wj.append(rows)
+                k_cols_joint_wj.append(cols)
+                self.k_data_joint.append(vals)
+                k_rows_joint_wj.append(cols)
+                k_cols_joint_wj.append(rows)
+                self.k_data_joint.append(vals)
+
+            # row and col indices for the entire stiffness matrix
+            self.k_cols = np.concatenate((self.k_cols, np.concatenate(k_cols_joint_wj)))
+            self.k_rows = np.concatenate((self.k_rows, np.concatenate(k_rows_joint_wj)))
+            self.total_size += n_con_wj
+
+            print('wing-jury joint added, total_size', self.total_size, '\n')
+
+            # --- strut-jury joint constraints ---
+            n_con_sj = self.n_con_sj = _get_joint_size(strut_jury_joint_type)
+            self.n_con += n_con_sj
+
+            # add Lagrange multipliers for joint constraints as state variables
+            self.add_output("joint_Lag_strut_jury", shape=(n_con_sj,), val=0.0)
+            self.joint_list.append("strut_jury")
+
+            k_rows_joint_sj = []
+            k_cols_joint_sj = []
+            for i, surface in enumerate([self.strut_surface, self.jury_surface]):
+                name = surface["name"]
+
+                # partials of joint constraint residuals w.r.t. displacement
+                if name == "strut":
+                    joint_idx = _get_joint_idx_from_y(surface, strut_jury_joint_y)
+                elif name == "jury":
+                    joint_idx = surface["mesh"].shape[1] - 1  # last index of jury surface
+                print(f'Strut-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+                rows, cols = _joint_rows_cols(strut_jury_joint_type, surface, joint_idx)
+                if i == 0:
+                    vals = np.ones(n_con_sj) * 1e9
+                else:
+                    vals = np.ones(n_con_sj) * -1e9
+                self.declare_partials("joint_Lag_strut_jury", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+
+                # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
+                self.declare_partials(f"disp_aug_{name}", "joint_Lag_strut_jury", rows=cols, cols=rows, val=vals)
+
+                # append these entries to the bottom of the global K matrix (and the transpose to the right)
+                rows += self.total_size
+                if name == "strut":
+                    cols += self.size[0]
+                if name == "jury":
+                    cols += self.size[0] + self.size[1]
+
+                k_rows_joint_sj.append(rows)
+                k_cols_joint_sj.append(cols)
+                self.k_data_joint.append(vals)
+                k_rows_joint_sj.append(cols)
+                k_cols_joint_sj.append(rows)
+                self.k_data_joint.append(vals)
+
+                print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
+
+            # row and col indices for the entire stiffness matrix
+            self.k_cols = np.concatenate((self.k_cols, np.concatenate(k_cols_joint_sj)))
+            self.k_rows = np.concatenate((self.k_rows, np.concatenate(k_rows_joint_sj)))
+            self.total_size += n_con_sj
+
+            print('strut-jury joint added, total_size', self.total_size, '\n')
 
     def apply_nonlinear(self, inputs, outputs, residuals):
         """
@@ -241,17 +380,22 @@ def apply_nonlinear(self, inputs, outputs, residuals):
         """
         K = self.assemble_CSC_K(inputs)
         disp = np.concatenate([outputs[f"disp_aug_{name}"] for name in self.surface_names])
-        joint_Lag = outputs["joint_Lag"]
+        joint_Lag = np.concatenate([outputs[f"joint_Lag_{name}"] for name in self.joint_list])
         u = np.concatenate([disp, joint_Lag])
         force = np.concatenate([inputs[f"forces_{name}"] for name in self.surface_names])
         rhs = np.concatenate([force, np.zeros(self.n_con)])
 
         r = K.dot(u) - rhs
 
-        size0, size1 = self.size[0], self.size[1]  # size of each residuals
+        size0, size1 = self.size[0], self.size[1]  # size of each component's K matrix
+        sum_size = sum(self.size)
         residuals[f"disp_aug_{self.surface_names[0]}"] = r[:size0]
         residuals[f"disp_aug_{self.surface_names[1]}"] = r[size0:size0 + size1]
-        residuals["joint_Lag"] = r[size0 + size1:]
+        residuals["joint_Lag_wing_strut"] = r[sum_size:sum_size + self.n_con_ws]
+        if self.include_jury:
+            residuals[f"disp_aug_{self.surface_names[2]}"] = r[size0 + size1:sum_size]
+            residuals["joint_Lag_wing_jury"] = r[sum_size + self.n_con_ws:sum_size + self.n_con_ws + self.n_con_wj]
+            residuals["joint_Lag_strut_jury"] = r[sum_size + self.n_con_ws + self.n_con_wj:]
         
     def solve_nonlinear(self, inputs, outputs):
         """
@@ -266,16 +410,29 @@ def solve_nonlinear(self, inputs, outputs):
         """
         # lu factorization for use with solve_linear
         K = self.assemble_CSC_K(inputs)
+
+        # Print the matrix K in a nicely formatted way
+        print('K (dense):')
+        print(K.toarray())
+
         self._lup = splu(K)
         force = np.concatenate([inputs[f"forces_{name}"] for name in self.surface_names])
         rhs = np.concatenate([force, np.zeros(self.n_con)])
 
+        print('\nrhs shape', rhs.shape)
+        print('K shape', K.shape)
+
         u = self._lup.solve(rhs)
 
         size0, size1 = self.size[0], self.size[1]  # size of each displacement vectors
+        sum_size = sum(self.size)
         outputs[f"disp_aug_{self.surface_names[0]}"] = u[:size0]
         outputs[f"disp_aug_{self.surface_names[1]}"] = u[size0:size0 + size1]
-        outputs["joint_Lag"] = u[size0 + size1:]
+        outputs["joint_Lag_wing_strut"] = u[sum_size:sum_size + self.n_con_ws]
+        if self.include_jury:
+            outputs[f"disp_aug_{self.surface_names[2]}"] = u[size0 + size1:sum_size]
+            outputs["joint_Lag_wing_jury"] = u[sum_size + self.n_con_ws:sum_size + self.n_con_ws + self.n_con_wj]
+            outputs["joint_Lag_strut_jury"] = u[sum_size + self.n_con_ws + self.n_con_wj:]
 
     def linearize(self, inputs, outputs, J):
         """
@@ -290,6 +447,7 @@ def linearize(self, inputs, outputs, J):
         J : Jacobian
             sub-jac components written to jacobian[output_name, input_name]
         """
+        raise RuntimeError("Not implemented")
         vec_size = self.options["vec_size"]
 
         name0, name1 = self.surface_names[0], self.surface_names[1]
@@ -325,6 +483,7 @@ def solve_linear(self, d_outputs, d_residuals, mode):
         mode : str
             either 'fwd' or 'rev'
         """
+        raise RuntimeError("Not implemented")
         vec_size = self.options["vec_size"]
         size0, size1 = self.size[0], self.size[1]
         name0, name1 = self.surface_names[0], self.surface_names[1]
@@ -334,31 +493,31 @@ def solve_linear(self, d_outputs, d_residuals, mode):
         if mode == "fwd":
             if vec_size > 1:
                 for j in range(vec_size):
-                    rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"][j], d_residuals[f"disp_aug_{name1}"][j], d_residuals["joint_Lag"][j]))
+                    rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"][j], d_residuals[f"disp_aug_{name1}"][j], d_residuals["joint_Lag_wing_strut"][j]))
                     sol = self._lup.solve(rhs)
                     d_outputs[f"disp_aug_{name0}"][j] = sol[:size0]
                     d_outputs[f"disp_aug_{name1}"][j] = sol[size0:size0 + size1]
-                    d_outputs["joint_Lag"][j] = sol[size0 + size1:]
+                    d_outputs["joint_Lag_wing_strut"][j] = sol[size0 + size1:]
             else:
-                rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"], d_residuals[f"disp_aug_{name1}"], d_residuals["joint_Lag"]))
+                rhs = np.concatenate((d_residuals[f"disp_aug_{name0}"], d_residuals[f"disp_aug_{name1}"], d_residuals["joint_Lag_wing_strut"]))
                 sol = self._lup.solve(rhs)
                 d_outputs[f"disp_aug_{name0}"] = sol[:size0]
                 d_outputs[f"disp_aug_{name1}"] = sol[size0:size0 + size1]
-                d_outputs["joint_Lag"] = sol[size0 + size1:]
+                d_outputs["joint_Lag_wing_strut"] = sol[size0 + size1:]
         else:
             if vec_size > 1:
                 for j in range(vec_size):
-                    rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"][j], d_outputs[f"disp_aug_{name1}"][j], d_outputs["joint_Lag"][j]))
+                    rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"][j], d_outputs[f"disp_aug_{name1}"][j], d_outputs["joint_Lag_wing_strut"][j]))
                     sol = self._lup.solve(rhs)
                     d_residuals[f"disp_aug_{name0}"][j] = sol[:size0]
                     d_residuals[f"disp_aug_{name1}"][j] = sol[size0:size0 + size1]
-                    d_residuals["joint_Lag"][j] = sol[size0 + size1:]
+                    d_residuals["joint_Lag_wing_strut"][j] = sol[size0 + size1:]
             else:
-                rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"], d_outputs[f"disp_aug_{name1}"], d_outputs["joint_Lag"]))
+                rhs = np.concatenate((d_outputs[f"disp_aug_{name0}"], d_outputs[f"disp_aug_{name1}"], d_outputs["joint_Lag_wing_strut"]))
                 sol = self._lup.solve(rhs)
                 d_residuals[f"disp_aug_{name0}"] = sol[:size0]
                 d_residuals[f"disp_aug_{name1}"] = sol[size0:size0 + size1]
-                d_residuals["joint_Lag"] = sol[size0 + size1:]
+                d_residuals["joint_Lag_wing_strut"] = sol[size0 + size1:]
 
     def assemble_CSC_K(self, inputs):
         """
@@ -387,6 +546,8 @@ def assemble_CSC_K(self, inputs):
             elif "root_BC_type" in surface and surface["root_BC_type"] == "pin":
                 # for pin BC (constraint translation and rotation in y and z)
                 data6 = np.full((5,), 1e9)
+            elif "root_BC_type" in surface and surface["root_BC_type"] == "none":
+                data6 = np.array([])
             else:
                 # for rigid BC (constraint translation and rotation)
                 data6 = np.full((6,), 1e9)
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index 95157a7dc..4edc3ae95 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -1,3 +1,4 @@
+import numpy as np
 import openmdao.api as om
 from openaerostruct.structures.create_rhs import CreateRHS
 from openaerostruct.structures.fem import FEM
@@ -113,6 +114,18 @@ def setup(self):
             # compute RHS force vector for wing and strut, respectively
             for surf in surface:
                 name = surf["name"]
+                if name in ["strut", "jury"]:
+                    # no fuel and point mass loads for struts
+                    surf["distributed_fuel_weight"] = False
+                    surf.pop("n_point_masses", None)
+
+                if name == "jury":
+                    # jury is structure-only component so no external loads
+                    ny = surf["mesh"].shape[1]
+                    indep = self.add_subsystem("zero", om.IndepVarComp())
+                    indep.add_output("jury_loads", val=np.zeros((ny, 6)))
+                    self.connect("zero.jury_loads", f"forces_{name}.loads")
+
                 self.add_subsystem(f'forces_{name}', FEMloads(surface=surf), promotes_inputs=["load_factor"])
                 self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
 

From f7aa2d9f740c64e97b4f6a30cda55b733b278193 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Mon, 4 Aug 2025 18:39:59 -0400
Subject: [PATCH 13/30] fixed strut nodal coordinate computation

---
 openaerostruct/structures/spatial_beam_setup.py  | 5 ++++-
 openaerostruct/structures/spatial_beam_states.py | 8 +++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/openaerostruct/structures/spatial_beam_setup.py b/openaerostruct/structures/spatial_beam_setup.py
index 7c4b490d8..cdfc7be35 100644
--- a/openaerostruct/structures/spatial_beam_setup.py
+++ b/openaerostruct/structures/spatial_beam_setup.py
@@ -12,11 +12,14 @@ class SpatialBeamSetup(om.Group):
 
     def initialize(self):
         self.options.declare("surface", types=dict)
+        self.options.declare("strut_braced", default=False, types=bool)
 
     def setup(self):
         surface = self.options["surface"]
 
-        self.add_subsystem("nodes", ComputeNodes(surface=surface), promotes_inputs=["mesh"], promotes_outputs=["nodes"])
+        if not (self.options["strut_braced"] and surface["name"] == "jury"):
+            # skip node computation for jury strut because no VLM mesh exists for jury strut
+            self.add_subsystem("nodes", ComputeNodes(surface=surface), promotes_inputs=["mesh"], promotes_outputs=["nodes"])
 
         self.add_subsystem(
             "assembly",
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index 4edc3ae95..4c6dc2e32 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -119,6 +119,12 @@ def setup(self):
                     surf["distributed_fuel_weight"] = False
                     surf.pop("n_point_masses", None)
 
+                # see if we have load_factor input
+                if surf["struct_weight_relief"] or surf["distributed_fuel_weight"] or "n_point_masses" in surf.keys():
+                    promotes_inputs = ["load_factor"]
+                else:
+                    promotes_inputs = []
+
                 if name == "jury":
                     # jury is structure-only component so no external loads
                     ny = surf["mesh"].shape[1]
@@ -126,7 +132,7 @@ def setup(self):
                     indep.add_output("jury_loads", val=np.zeros((ny, 6)))
                     self.connect("zero.jury_loads", f"forces_{name}.loads")
 
-                self.add_subsystem(f'forces_{name}', FEMloads(surface=surf), promotes_inputs=["load_factor"])
+                self.add_subsystem(f'forces_{name}', FEMloads(surface=surf), promotes_inputs=promotes_inputs)
                 self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
 
             # FEM of wing-strut system

From 086f271f8296a5ed1caf823f292fb8f8de250efe Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Mon, 4 Aug 2025 21:21:38 -0400
Subject: [PATCH 14/30] working on jury FEM, something is wrong

---
 openaerostruct/structures/fem_strut_braced.py | 29 ++-----------
 openaerostruct/structures/local_stiff.py      | 42 +++++++++++--------
 .../structures/spatial_beam_states.py         |  5 +++
 3 files changed, 33 insertions(+), 43 deletions(-)

diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 628cdf698..64d754657 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -145,9 +145,7 @@ def setup(self):
         wing_strut_joint_y = self.strut_surface["wing_strut_joint_y"]
 
         if self.include_jury:
-            wing_jury_joint_type = self.jury_surface["wing_jury_joint_type"]
             wing_jury_joint_y = self.jury_surface["wing_jury_joint_y"]
-            strut_jury_joint_type = self.jury_surface["strut_jury_joint_type"]
             strut_jury_joint_y = self.jury_surface["strut_jury_joint_y"]
 
         # prepare inputs
@@ -253,18 +251,14 @@ def setup(self):
             k_cols_joint_ws.append(rows)
             self.k_data_joint.append(vals)
 
-            print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
-
         # row and col indices for the entire stiffness matrix (that combines wing, strut, (jury), and joint constraints)
         self.k_cols = np.concatenate(k_cols + k_cols_joint_ws)
         self.k_rows = np.concatenate(k_rows + k_rows_joint_ws)
         self.total_size = sum(self.size) + n_con_ws   # size (num rows) of total stiffness matrix (K matrices + joint constraints)
 
-        print('wing-strut joint added, total_size', self.total_size, '\n')
-
         if self.include_jury:
             # --- wing-jury joint constraints ---
-            n_con_wj = self.n_con_wj = _get_joint_size(wing_jury_joint_type)
+            n_con_wj = self.n_con_wj = 6  # need to constrain all DOFs to avoid singularity
             self.n_con += n_con_wj
 
             # add Lagrange multipliers for joint constraints as state variables
@@ -282,7 +276,7 @@ def setup(self):
                 elif name == "jury":
                     joint_idx = 0  # jury index starts from 0 at the wing-jury joint
                 print(f'Wing-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
-                rows, cols = _joint_rows_cols(wing_jury_joint_type, surface, joint_idx)
+                rows, cols = _joint_rows_cols("rigid", surface, joint_idx)
                 if i == 0:
                     vals = np.ones(n_con_wj) * 1e9
                 else:
@@ -297,8 +291,6 @@ def setup(self):
                 if name == "jury":
                     cols += self.size[0] + self.size[1]
 
-                print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
-
                 k_rows_joint_wj.append(rows)
                 k_cols_joint_wj.append(cols)
                 self.k_data_joint.append(vals)
@@ -311,10 +303,8 @@ def setup(self):
             self.k_rows = np.concatenate((self.k_rows, np.concatenate(k_rows_joint_wj)))
             self.total_size += n_con_wj
 
-            print('wing-jury joint added, total_size', self.total_size, '\n')
-
             # --- strut-jury joint constraints ---
-            n_con_sj = self.n_con_sj = _get_joint_size(strut_jury_joint_type)
+            n_con_sj = self.n_con_sj = 6
             self.n_con += n_con_sj
 
             # add Lagrange multipliers for joint constraints as state variables
@@ -332,7 +322,7 @@ def setup(self):
                 elif name == "jury":
                     joint_idx = surface["mesh"].shape[1] - 1  # last index of jury surface
                 print(f'Strut-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
-                rows, cols = _joint_rows_cols(strut_jury_joint_type, surface, joint_idx)
+                rows, cols = _joint_rows_cols("rigid", surface, joint_idx)
                 if i == 0:
                     vals = np.ones(n_con_sj) * 1e9
                 else:
@@ -356,15 +346,11 @@ def setup(self):
                 k_cols_joint_sj.append(rows)
                 self.k_data_joint.append(vals)
 
-                print(f'name = {name}, rows = {rows}, cols = {cols}, vals = {vals}')
-
             # row and col indices for the entire stiffness matrix
             self.k_cols = np.concatenate((self.k_cols, np.concatenate(k_cols_joint_sj)))
             self.k_rows = np.concatenate((self.k_rows, np.concatenate(k_rows_joint_sj)))
             self.total_size += n_con_sj
 
-            print('strut-jury joint added, total_size', self.total_size, '\n')
-
     def apply_nonlinear(self, inputs, outputs, residuals):
         """
         R = Ax - b.
@@ -411,17 +397,10 @@ def solve_nonlinear(self, inputs, outputs):
         # lu factorization for use with solve_linear
         K = self.assemble_CSC_K(inputs)
 
-        # Print the matrix K in a nicely formatted way
-        print('K (dense):')
-        print(K.toarray())
-
         self._lup = splu(K)
         force = np.concatenate([inputs[f"forces_{name}"] for name in self.surface_names])
         rhs = np.concatenate([force, np.zeros(self.n_con)])
 
-        print('\nrhs shape', rhs.shape)
-        print('K shape', K.shape)
-
         u = self._lup.solve(rhs)
 
         size0, size1 = self.size[0], self.size[1]  # size of each displacement vectors
diff --git a/openaerostruct/structures/local_stiff.py b/openaerostruct/structures/local_stiff.py
index f4b5f321e..3a26d4c37 100644
--- a/openaerostruct/structures/local_stiff.py
+++ b/openaerostruct/structures/local_stiff.py
@@ -32,6 +32,7 @@
 class LocalStiff(om.ExplicitComponent):
     def initialize(self):
         self.options.declare("surface", types=dict)
+        self.options.declare("strut_braced", default=False, types=bool)
 
     def setup(self):
         surface = self.options["surface"]
@@ -55,6 +56,11 @@ def setup(self):
         self.declare_partials("local_stiff", "Iz", rows=rows, cols=cols)
         self.declare_partials("local_stiff", "element_lengths", rows=rows, cols=cols)
 
+        self.scale_EI = 1.0
+        if self.options["strut_braced"] and surface["name"] == "jury":
+            # for jury strut, we set very low bending stiffness to effectively make this a rod element
+            self.scale_EI = 1.0
+
     def compute(self, inputs, outputs):
         surface = self.options["surface"]
 
@@ -76,8 +82,8 @@ def compute(self, inputs, outputs):
 
         for i in range(4):
             for j in range(4):
-                outputs["local_stiff"][:, 4 + i, 4 + j] = E * Iy / L**3 * coeffs_y[i, j]
-                outputs["local_stiff"][:, 8 + i, 8 + j] = E * Iz / L**3 * coeffs_z[i, j]
+                outputs["local_stiff"][:, 4 + i, 4 + j] = E * Iy / L**3 * coeffs_y[i, j] * self.scale_EI
+                outputs["local_stiff"][:, 8 + i, 8 + j] = E * Iz / L**3 * coeffs_z[i, j] * self.scale_EI
 
         for i in [1, 3]:
             for j in range(4):
@@ -122,31 +128,31 @@ def compute_partials(self, inputs, partials):
 
         for i in range(4):
             for j in range(4):
-                derivs_Iy[:, 4 + i, 4 + j] = E / L**3 * coeffs_y[i, j]
-                derivs_L[:, 4 + i, 4 + j] = -3 * E * Iy / L**4 * coeffs_y[i, j]
+                derivs_Iy[:, 4 + i, 4 + j] = E / L**3 * coeffs_y[i, j] * self.scale_EI
+                derivs_L[:, 4 + i, 4 + j] = -3 * E * Iy / L**4 * coeffs_y[i, j] * self.scale_EI
 
-                derivs_Iz[:, 8 + i, 8 + j] = E / L**3 * coeffs_z[i, j]
-                derivs_L[:, 8 + i, 8 + j] = -3 * E * Iz / L**4 * coeffs_z[i, j]
+                derivs_Iz[:, 8 + i, 8 + j] = E / L**3 * coeffs_z[i, j] * self.scale_EI
+                derivs_L[:, 8 + i, 8 + j] = -3 * E * Iz / L**4 * coeffs_z[i, j] * self.scale_EI
 
         for i in [1, 3]:
             for j in range(4):
-                derivs_Iy[:, 4 + i, 4 + j] = E / L**2 * coeffs_y[i, j]
-                derivs_L[:, 4 + i, 4 + j] = -2 * E * Iy / L**3 * coeffs_y[i, j]
+                derivs_Iy[:, 4 + i, 4 + j] = E / L**2 * coeffs_y[i, j] * self.scale_EI
+                derivs_L[:, 4 + i, 4 + j] = -2 * E * Iy / L**3 * coeffs_y[i, j] * self.scale_EI
 
-                derivs_Iz[:, 8 + i, 8 + j] = E / L**2 * coeffs_z[i, j]
-                derivs_L[:, 8 + i, 8 + j] = -2 * E * Iz / L**3 * coeffs_z[i, j]
+                derivs_Iz[:, 8 + i, 8 + j] = E / L**2 * coeffs_z[i, j] * self.scale_EI
+                derivs_L[:, 8 + i, 8 + j] = -2 * E * Iz / L**3 * coeffs_z[i, j] * self.scale_EI
         for i in range(4):
             for j in [1, 3]:
-                derivs_Iy[:, 4 + i, 4 + j] = E / L**2 * coeffs_y[i, j]
-                derivs_L[:, 4 + i, 4 + j] = -2 * E * Iy / L**3 * coeffs_y[i, j]
+                derivs_Iy[:, 4 + i, 4 + j] = E / L**2 * coeffs_y[i, j] * self.scale_EI
+                derivs_L[:, 4 + i, 4 + j] = -2 * E * Iy / L**3 * coeffs_y[i, j] * self.scale_EI
 
-                derivs_Iz[:, 8 + i, 8 + j] = E / L**2 * coeffs_z[i, j]
-                derivs_L[:, 8 + i, 8 + j] = -2 * E * Iz / L**3 * coeffs_z[i, j]
+                derivs_Iz[:, 8 + i, 8 + j] = E / L**2 * coeffs_z[i, j] * self.scale_EI
+                derivs_L[:, 8 + i, 8 + j] = -2 * E * Iz / L**3 * coeffs_z[i, j] * self.scale_EI
 
         for i in [1, 3]:
             for j in [1, 3]:
-                derivs_Iy[:, 4 + i, 4 + j] = E / L * coeffs_y[i, j]
-                derivs_L[:, 4 + i, 4 + j] = -E * Iy / L**2 * coeffs_y[i, j]
+                derivs_Iy[:, 4 + i, 4 + j] = E / L * coeffs_y[i, j] * self.scale_EI
+                derivs_L[:, 4 + i, 4 + j] = -E * Iy / L**2 * coeffs_y[i, j] * self.scale_EI
 
-                derivs_Iz[:, 8 + i, 8 + j] = E / L * coeffs_z[i, j]
-                derivs_L[:, 8 + i, 8 + j] = -E * Iz / L**2 * coeffs_z[i, j]
+                derivs_Iz[:, 8 + i, 8 + j] = E / L * coeffs_z[i, j] * self.scale_EI
+                derivs_L[:, 8 + i, 8 + j] = -E * Iz / L**2 * coeffs_z[i, j] * self.scale_EI
diff --git a/openaerostruct/structures/spatial_beam_states.py b/openaerostruct/structures/spatial_beam_states.py
index 4c6dc2e32..265c8f0d4 100644
--- a/openaerostruct/structures/spatial_beam_states.py
+++ b/openaerostruct/structures/spatial_beam_states.py
@@ -111,6 +111,11 @@ def setup(self):
             self.add_subsystem("disp", Disp(surface=surface), promotes_inputs=["*"], promotes_outputs=["*"])
 
         else:
+            # set no root boundary conditions for jury strut
+            for i, surf in enumerate(surface):
+                if surf["name"] == "jury":
+                    surface[i]["root_BC_type"] = "none"
+
             # compute RHS force vector for wing and strut, respectively
             for surf in surface:
                 name = surf["name"]

From 9f87f03df686c503db81de653bfb7ccca7eeea5e Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Fri, 8 Aug 2025 00:35:59 -0400
Subject: [PATCH 15/30] jury strut works for aerostructural analysis

---
 .../integration/aerostruct_groups.py          | 109 +++++++++--
 openaerostruct/structures/disp.py             |   3 +
 .../structures/failure_buckling_ks.py         |  27 ++-
 openaerostruct/structures/fem_strut_braced.py |  19 +-
 .../structures/spatial_beam_functionals.py    |  11 +-
 .../spatial_beam_states_truss_braced.py       | 181 ++++++++++++++++++
 6 files changed, 309 insertions(+), 41 deletions(-)
 create mode 100644 openaerostruct/structures/spatial_beam_states_truss_braced.py

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 8ecd2f1f6..95e230bb0 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -1,8 +1,11 @@
 from openaerostruct.aerodynamics.geometry import VLMGeometry
 from openaerostruct.geometry.geometry_group import Geometry
 from openaerostruct.transfer.displacement_transfer_group import DisplacementTransferGroup
+from openaerostruct.structures.failure_buckling_ks import EulerColumnBucklingFailureKS
+from openaerostruct.structures.fem_strut_braced import get_joint_idx_from_y
 from openaerostruct.structures.spatial_beam_setup import SpatialBeamSetup
 from openaerostruct.structures.spatial_beam_states import SpatialBeamStates
+from openaerostruct.structures.spatial_beam_states_truss_braced import SpatialBeamStatesTrussBraced
 from openaerostruct.aerodynamics.functionals import VLMFunctionals
 from openaerostruct.structures.spatial_beam_functionals import SpatialBeamFunctionals
 from openaerostruct.functionals.total_performance import TotalPerformance
@@ -190,9 +193,6 @@ def setup(self):
             if "panel_buckling" in surface and surface["panel_buckling"]:
                 promotes_inputs += ["skin_thickness", "t_over_c", "fem_chords"]
                 promotes_outputs += ["failure_local_buckling"]
-            if "column_buckling" in surface and surface["column_buckling"]:
-                promotes_inputs += ["Iz", "joint_load"]
-                promotes_outputs += ["failure_column_buckling"]
 
             self.add_subsystem(
                 "struct_funcs",
@@ -235,6 +235,17 @@ def setup(self):
                     pass
                 else:
                     raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+
+                # add coupled FEM group
+                coupled.add_subsystem(
+                    "FEM_SBW",
+                    SpatialBeamStates(surface=surfaces_all, strut_braced=True),
+                    promotes_inputs=["*"],
+                    promotes_outputs=["disp_*"]
+                )
+
+                include_jury = False
+
             elif len(surfaces) == 3:
                 # wing + strut + jury
                 if surfaces[0]["name"] == "wing" and surfaces[1]["name"] == "strut" and surfaces[2]["name"] == "jury":
@@ -248,19 +259,22 @@ def setup(self):
                 surfaces[2]["root_BC_type"] = "none"
                 surfaces_all[2]["root_BC_type"] = "none"
 
-            # add coupled FEM group
-            coupled.add_subsystem(
-                "FEM_SBW",
-                SpatialBeamStates(surface=surfaces_all, strut_braced=True),
-                promotes_inputs=["*"],
-                promotes_outputs=["disp_*"]
-            )
+                # add coupled FEM group
+                coupled.add_subsystem(
+                    "FEM_SBW",
+                    SpatialBeamStatesTrussBraced(surfaces=surfaces_all, strut_braced=True),
+                    promotes_inputs=["*"],
+                    promotes_outputs=["disp_*"]
+                )
+
+                include_jury = True
+                surface_jury = surfaces[2]
         else:
             surfaces_all = surfaces
             surfaces_AS = surfaces
 
         # connections for all structural components
-        for surface in surfaces_all:
+        for surface in surfaces_AS:
             name = surface["name"]
 
             # connect displacements to the performance group
@@ -274,7 +288,13 @@ def setup(self):
             # Connect the output of the loads component with the FEM
             # displacement parameter. This links the coupling within the coupled
             # group that necessitates the subgroup solver.
-            loads_target = f"forces_{name}.loads" if self.options["strut_braced"] else f"{name}.loads"
+            if self.options["strut_braced"] and include_jury:
+                loads_target = f"external_loads_{name}.loads"
+            elif self.options["strut_braced"]:
+                loads_target = f"forces_{name}.loads"
+            else:
+                loads_target = f"{name}.loads"
+
             coupled.connect(name + "_loads.loads", loads_target)
 
             # Connect displacement from FEM to transfer model. This is automatically done by promotion for non-SBW cases
@@ -404,12 +424,71 @@ def setup(self):
                 name + "_perf", perf_group, promotes_inputs=["rho", "v", "alpha", "beta", "re", "Mach_number"]
             )
 
+            # column buckling failure for strut
+            if "column_buckling" in surface and surface["column_buckling"]:
+                if include_jury:
+                    ny = surface["mesh"].shape[1]
+                    passthru = om.ExecComp(
+                        ["nodes_all = nodes", "Iz_all = Iz"],
+                        nodes_all={'units': 'm', 'shape': (ny, 3)},
+                        nodes={'units': 'm', 'shape': (ny, 3)},
+                        Iz_all={'units': 'm**4', 'shape': ny - 1},
+                        Iz={'units': 'm**4', 'shape': ny - 1}
+                    )
+                    perf_group.add_subsystem("passthru", passthru, promotes_inputs=["nodes", "Iz"])
+
+                    # strut-jury joint index
+                    joint_idx = get_joint_idx_from_y(surface, surface_jury["strut_jury_joint_y"])
+                    ny_outer = joint_idx + 1  # number of nodes from wing to strut-jury joint, including the joint node
+                    ny_inner = ny - joint_idx  # number of nodes from strut-jury joint to root, including the joint node
+
+                    # column buckling for outer strut segment. Use strut-wing joint load as a compression load
+                    perf_group.add_subsystem(
+                        "column_buckling_outer",
+                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_outer),
+                        promotes_inputs=[("joint_load", "joint_load_strut_wing")],
+                        promotes_outputs=[("failure_column_buckling", "failure_column_buckling_outer")]
+                    )
+                    perf_group.connect("passthru.nodes_all", "column_buckling_outer.nodes", src_indices=om.slicer[0:ny_outer, :])
+                    perf_group.connect("passthru.Iz_all", "column_buckling_outer.Iz", src_indices=om.slicer[0:ny_outer - 1])
+                    
+                    # column buckling for inner strut segment. Use strut-root reaction force as a compression load
+                    perf_group.add_subsystem(
+                        "column_buckling_inner",
+                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_inner),
+                        promotes_inputs=[("joint_load", "reaction_load_strut_root")],
+                        promotes_outputs=[("failure_column_buckling", "failure_column_buckling_inner")]
+                    )
+                    perf_group.connect("passthru.nodes_all", "column_buckling_inner.nodes", src_indices=om.slicer[joint_idx:, :])
+                    perf_group.connect("passthru.Iz_all", "column_buckling_inner.Iz", src_indices=om.slicer[joint_idx:])
+                else:
+                    # column buckling for the entire strut. Use strut-wing joint load as a compression load
+                    ny = surface["mesh"].shape[1]
+                    perf_group.add_subsystem(
+                        "column_buckling",
+                        EulerColumnBucklingFailureKS(surface=surface, ny=ny, joint_load_type="vector"),
+                        promotes_inputs=["nodes", "Iz", ("joint_load", "joint_load_strut_wing")],
+                        promotes_outputs=["failure_column_buckling"]
+                    )
+
         # post-AS-analysis computations for structure-only components
+        # for surface in [s for s in surfaces_all if s not in surfaces_AS]:
+        #     self.add_subsystem(
+        #         f"{surface["name"]}_perf",
+        #         SpatialBeamFunctionals(surface=surface),
+        #     )
+
+        # column buckling failure for jury strut
         for surface in [s for s in surfaces_all if s not in surfaces_AS]:
-            self.add_subsystem(
-                f"{surface["name"]}_perf",
-                SpatialBeamFunctionals(surface=surface),
+            ny = surface["mesh"].shape[1]
+            perf_group = self.add_subsystem(f"{surface["name"]}_perf", om.Group())
+            perf_group.add_subsystem(
+                "column_buckling",
+                EulerColumnBucklingFailureKS(surface=surface, ny=ny, joint_load_type="scaler"),
+                promotes_inputs=["nodes", "Iz", "joint_load"],
+                promotes_outputs=["failure_column_buckling"]
             )
+            self.connect("coupled.FEM_SBW.joint_axias_force", f"{surface["name"]}_perf.joint_load")
 
         # Add functionals to evaluate performance of the system.
         # Note that only the interesting results are promoted here; not all
diff --git a/openaerostruct/structures/disp.py b/openaerostruct/structures/disp.py
index 60f1052ec..f6804583e 100644
--- a/openaerostruct/structures/disp.py
+++ b/openaerostruct/structures/disp.py
@@ -47,12 +47,15 @@ def setup(self):
         self.add_input("disp_aug", val=np.zeros((self.ny * 6 + dof_of_boundary)), units="m")
 
         self.add_output("disp", val=np.zeros((self.ny, 6)), units="m")
+        self.add_output("boundary_Lag", val=np.zeros(dof_of_boundary))  # Lagrange multipliers for boundary conditions
 
         n = self.ny * 6
         arange = np.arange((n))
         self.declare_partials("disp", "disp_aug", val=1.0, rows=arange, cols=arange)
+        self.declare_partials("boundary_Lag", "disp_aug", val=1.0, rows=np.arange(dof_of_boundary), cols=np.arange(dof_of_boundary) + n)
 
     def compute(self, inputs, outputs):
         # Obtain the relevant portions of disp_aug and store the reshaped
         # displacements in disp
         outputs["disp"] = inputs["disp_aug"][:self.ny * 6].reshape((-1, 6))
+        outputs["boundary_Lag"] = inputs["disp_aug"][self.ny * 6:] * 1.0
diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
index 881dbdb83..b2f8dcadf 100644
--- a/openaerostruct/structures/failure_buckling_ks.py
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -146,8 +146,8 @@ class EulerColumnBucklingFailureKS(om.ExplicitComponent):
     ----------
     nodes[ny, 3] : numpy array
         FEM node coordinates.
-    joint_load[3] : numpy array
-        Force vector applied to the strut at the joint.
+    joint_load : numpy array or float
+        Force vector applied to the strut at the joint. If `joint_load_type` is `vector`, this is a 3-element vector. If `joint_load_type` is `scaler`, this is a scalar tensile force.
     Iz[ny-1] : numpy array
         Moment of inertia of the strut about the z-axis.
 
@@ -160,14 +160,20 @@ class EulerColumnBucklingFailureKS(om.ExplicitComponent):
 
     def initialize(self):
         self.options.declare("surface", types=dict)
+        self.options.declare("ny", desc="number of nodes in the strut")
         self.options.declare("rho", types=float, default=100.0, desc="KS aggregation smoothness parameter")
+        self.options.declare("joint_load_type", types=str, default="vector", desc="type of joint load, either `vector` or `scaler`. If scaler, this should be the axial tension force")
 
     def setup(self):
-        surface = self.options["surface"]
-        ny = surface["mesh"].shape[1]
+        ny = self.options["ny"]
 
         self.add_input("nodes", shape=(ny, 3), units="m", desc="FEM node coordinates")
-        self.add_input("joint_load", shape=3, desc="load vector applied to the strut at the joint")
+        if self.options["joint_load_type"] == "vector":
+            self.add_input("joint_load", shape=3, desc="load vector applied to the strut at the joint")
+        elif self.options["joint_load_type"] == "scaler":
+            self.add_input("joint_load", shape=1, desc="tension force applied to the strut at the joint")
+        else:
+            raise ValueError(f"Invalid joint load type: {self.options['joint_load_type']}")
         self.add_input("Iz", shape=(ny - 1), units="m**4")  # use Iz because Iz < Iy
 
         self.add_output("failure_column_buckling", val=0.0, desc="Euler column buckling failure metric, should be <= 0")
@@ -192,10 +198,13 @@ def compute(self, inputs, outputs):
         strut_len = np.linalg.norm(nodes[0, :] - nodes[-1, :]) * column_length_factor
 
         # compression load
-        strut_direction = (nodes[-1, :] - nodes[0, :])
-        strut_direction /= np.linalg.norm(strut_direction)  # unit magniture
-        # multiply by 1e9 to make the units to N (FEM normalizes this by 1e9)
-        comp_load = np.dot(joint_load, strut_direction) * 1e9
+        if self.options["joint_load_type"] == "vector":
+            strut_direction = (nodes[-1, :] - nodes[0, :])
+            strut_direction /= np.linalg.norm(strut_direction)  # unit magniture
+            # multiply by 1e9 to make the units to N (FEM normalizes this by 1e9)
+            comp_load = np.dot(joint_load, strut_direction) * 1e9
+        elif self.options["joint_load_type"] == "scaler":
+            comp_load = -joint_load  # flip sign to make compression positive
         
         # critical load with safety factor of 1.5
         sf = 1.5
diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 64d754657..b3c3526a2 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -23,13 +23,13 @@ def _get_joint_size(joint_type):
         raise ValueError("Joint type must be either 'pin' or 'rigid'.")
     return n_con
 
-def _get_joint_idx_from_y(surface, joint_y):
+def get_joint_idx_from_y(surface, joint_y):
     """
     Return the joint index from the joint y (spanwise) coordinate.
     This is only good for wing or strut, but do not use for jury (or any vertical surface)
     """
     if surface["name"] == "jury":
-        raise RuntimeError("Cannot use _get_joint_idx_from_y for jury surface.")
+        raise RuntimeError("Cannot use get_joint_idx_from_y for jury surface.")
     joint_idx = np.argmin((np.abs(surface["mesh"][0, :, 1]) - abs(joint_y))**2)
     return joint_idx
 
@@ -127,6 +127,7 @@ def setup(self):
             self.wing_surface = self.surfaces[0]
             self.strut_surface = self.surfaces[1]
             self.jury_surface = self.surfaces[2]
+            raise NotImplementedError("Jury strut FEM model is still under debugging")
         else:
             raise ValueError("FEMStrutBraced component requires exactly two or three surfaces (wing, strut, and/or jury).")
 
@@ -226,7 +227,7 @@ def setup(self):
             name = surface["name"]
 
             # partials of joint constraint residuals w.r.t. displacement
-            joint_idx = _get_joint_idx_from_y(surface, wing_strut_joint_y)
+            joint_idx = get_joint_idx_from_y(surface, wing_strut_joint_y)
             print(f'Wing-strut joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
             rows, cols = _joint_rows_cols(wing_strut_joint_type, surface, joint_idx)
             if i == 0:
@@ -272,7 +273,7 @@ def setup(self):
 
                 # partials of joint constraint residuals w.r.t. displacement
                 if name == "wing":
-                    joint_idx = _get_joint_idx_from_y(surface, wing_jury_joint_y)
+                    joint_idx = get_joint_idx_from_y(surface, wing_jury_joint_y)
                 elif name == "jury":
                     joint_idx = 0  # jury index starts from 0 at the wing-jury joint
                 print(f'Wing-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
@@ -318,7 +319,7 @@ def setup(self):
 
                 # partials of joint constraint residuals w.r.t. displacement
                 if name == "strut":
-                    joint_idx = _get_joint_idx_from_y(surface, strut_jury_joint_y)
+                    joint_idx = get_joint_idx_from_y(surface, strut_jury_joint_y)
                 elif name == "jury":
                     joint_idx = surface["mesh"].shape[1] - 1  # last index of jury surface
                 print(f'Strut-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
@@ -426,7 +427,9 @@ def linearize(self, inputs, outputs, J):
         J : Jacobian
             sub-jac components written to jacobian[output_name, input_name]
         """
-        raise RuntimeError("Not implemented")
+        if self.include_jury:
+            raise RuntimeError("Not implemented for jury strut")
+
         vec_size = self.options["vec_size"]
 
         name0, name1 = self.surface_names[0], self.surface_names[1]
@@ -462,7 +465,9 @@ def solve_linear(self, d_outputs, d_residuals, mode):
         mode : str
             either 'fwd' or 'rev'
         """
-        raise RuntimeError("Not implemented")
+        if self.include_jury:
+            raise RuntimeError("Not implemented for jury strut")
+
         vec_size = self.options["vec_size"]
         size0, size1 = self.size[0], self.size[1]
         name0, name1 = self.surface_names[0], self.surface_names[1]
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index 705ad5163..5dca4f64a 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -8,7 +8,7 @@
 from openaerostruct.structures.non_intersecting_thickness import NonIntersectingThickness
 from openaerostruct.structures.failure_exact import FailureExact
 from openaerostruct.structures.failure_ks import FailureKS
-from openaerostruct.structures.failure_buckling_ks import PanelLocalBucklingFailureKS, EulerColumnBucklingFailureKS
+from openaerostruct.structures.failure_buckling_ks import PanelLocalBucklingFailureKS
 
 
 class SpatialBeamFunctionals(om.Group):
@@ -89,12 +89,3 @@ def setup(self):
             self.connect("vonmises.lower_skin_comp_stress", "local_buckling.lower_skin_comp_stress")
             self.connect("vonmises.front_spar_shear_stress", "local_buckling.front_spar_shear_stress")
             self.connect("vonmises.rear_spar_shear_stress", "local_buckling.rear_spar_shear_stress")
-
-        # global Euler column buckling
-        if "column_buckling" in surface and surface["column_buckling"]:
-            self.add_subsystem(
-                "column_buckling",
-                EulerColumnBucklingFailureKS(surface=surface),
-                promotes_inputs=["nodes", "joint_load", "Iz"],
-                promotes_outputs=["failure_column_buckling"]
-            )
diff --git a/openaerostruct/structures/spatial_beam_states_truss_braced.py b/openaerostruct/structures/spatial_beam_states_truss_braced.py
new file mode 100644
index 000000000..794aa51a5
--- /dev/null
+++ b/openaerostruct/structures/spatial_beam_states_truss_braced.py
@@ -0,0 +1,181 @@
+import numpy as np
+import openmdao.api as om
+from openaerostruct.structures.create_rhs import CreateRHS
+from openaerostruct.structures.fem import FEM
+from openaerostruct.structures.fem_strut_braced import FEMStrutBraced, get_joint_idx_from_y
+from openaerostruct.structures.disp import Disp
+from openaerostruct.structures.wing_weight_loads import StructureWeightLoads
+from openaerostruct.structures.fuel_loads import FuelLoads
+from openaerostruct.structures.total_loads import TotalLoads
+from openaerostruct.structures.compute_point_mass_loads import ComputePointMassLoads
+from openaerostruct.structures.compute_thrust_loads import ComputeThrustLoads
+from openaerostruct.structures.spatial_beam_states import FEMloads
+
+
+class SpatialBeamStatesTrussBraced(om.Group):
+    """
+    Group that contains the spatial beam states for truss-braced wing model
+    that combines FEM for wing and main strut + analytic rod for jury strut
+    """
+
+    def initialize(self):
+        self.options.declare("surfaces", types=list)
+        self.options.declare("strut_braced", default=True, types=bool)
+
+    def setup(self):
+        surfaces = self.options["surfaces"]
+
+        if len(surfaces) != 3:
+            raise ValueError("surface must have 3 surfaces: wing, strut, and jury")
+
+        surf_wing = surfaces[0]
+        surf_strut = surfaces[1]
+        surf_jury = surfaces[2]
+
+        # no fuel and point mass loads for struts and jury
+        surf_strut["distributed_fuel_weight"] = False
+        surf_strut.pop("n_point_masses", None)
+        surf_jury["distributed_fuel_weight"] = False
+        surf_jury.pop("n_point_masses", None)
+
+        # find spanwise index of jury-wing and jury-strut joints
+        jury_joint_idx = {
+            "wing": get_joint_idx_from_y(surf_wing, surf_jury["wing_jury_joint_y"]),
+            "strut": get_joint_idx_from_y(surf_strut, surf_jury["strut_jury_joint_y"]),
+        }
+
+        # --- Strut-braced wing FEM ---
+        # compute RHS force vector for wing and strut
+        for surf in [surf_wing, surf_strut]:
+            name = surf["name"]
+
+            # compute jury joint loads
+            self.add_subsystem(f"external_loads_{name}", JuryJointLoads(surface=surf, joint_idx=jury_joint_idx[name]), promotes_inputs=["jury_nodes", "joint_axias_force"])
+
+            # see if we have load_factor input
+            if surf["struct_weight_relief"] or surf["distributed_fuel_weight"] or "n_point_masses" in surf.keys():
+                promotes_inputs = ["load_factor"]
+            else:
+                promotes_inputs = []
+
+            # RHS vector
+            self.add_subsystem(f'forces_{name}', FEMloads(surface=surf), promotes_inputs=promotes_inputs)
+            self.connect(f"external_loads_{name}.loads_out", f"forces_{name}.loads")
+            self.connect(f"forces_{name}.forces", f"fem.forces_{name}")
+    
+        # FEM of wing-strut system
+        self.add_subsystem("fem", FEMStrutBraced(surfaces=[surf_wing, surf_strut]), promotes_inputs=["local_stiff_transformed_*"])
+        
+        # reshape displacements and remove Lagrange multipliers from disp_aug
+        for surf in [surf_wing, surf_strut]:
+            name = surf["name"]
+            self.add_subsystem(f"disp_{name}", Disp(surface=surf), promotes_outputs=[("disp", f"disp_{name}")])
+            self.connect(f"fem.disp_aug_{name}", f"disp_{name}.disp_aug")
+
+        # --- compute jury axial displacement from strut-braced wing FEM solution ---
+        self.add_subsystem("jury_disp_from_SBW", JuryDispFromSBW(), promotes_inputs=["jury_nodes"], promotes_outputs=["disp_jury"])
+        self.connect("disp_wing", "jury_disp_from_SBW.disp_wing", src_indices=om.slicer[jury_joint_idx["wing"], :3])
+        self.connect("disp_strut", "jury_disp_from_SBW.disp_strut", src_indices=om.slicer[jury_joint_idx["strut"], :3])
+
+        # --- Compute jury axial load from displacement ---
+        self.add_subsystem("jury_load", JuryStrutRod(surface=surf_jury), promotes_inputs=["jury_nodes", "jury_A", "disp_jury"], promotes_outputs=["joint_axias_force"])
+
+        self.nonlinear_solver = om.NewtonSolver(solve_subsystems=True, maxiter=20, atol=1e-6, rtol=1e-6, err_on_non_converge=True, iprint=0)
+        self.linear_solver = om.DirectSolver()
+
+        
+class JuryJointLoads(om.ExplicitComponent):
+    """
+    Compute jury joint loads
+    """
+
+    def initialize(self):
+        self.options.declare("surface", types=dict)
+        self.options.declare("joint_idx", desc="spanwise index of jury joint on this surface")
+
+    def setup(self):
+        surface = self.options["surface"]
+        ny = surface["mesh"].shape[1]
+
+        self.add_input("jury_nodes", val=np.zeros((2, 3)), units='m')
+        self.add_input("joint_axias_force", val=0., units="N", desc="axial force on jury joint. Positive = tension")
+        self.add_input("loads", val=np.ones((ny, 6)), units="N")
+        self.add_output("loads_out", val=np.ones((ny, 6)), units="N")
+
+        self.declare_partials("loads_out", ["jury_nodes", "joint_axias_force"], method="cs", step=1e-100)
+        self.declare_partials("loads_out", "loads", rows=np.arange(ny * 6), cols=np.arange(ny * 6), val=np.ones(ny * 6))
+
+    def compute(self, inputs, outputs):
+        surface = self.options["surface"]
+        joint_idx = self.options["joint_idx"]
+
+        jury_nodes = inputs["jury_nodes"]
+
+        # direction of jury struts = axial force. Jury node is defined from wing to node
+        if surface["name"] == "wing":
+            load_dir = jury_nodes[-1, :] - jury_nodes[0, :]
+        elif surface["name"] == "strut":
+            load_dir = jury_nodes[0, :] - jury_nodes[-1, :]
+        else:
+            raise ValueError(f"Jury joint loads are only supported for wing and strut surfaces, not {surface['name']}")
+        load_dir = load_dir / np.linalg.norm(load_dir)
+
+        # compute load vector and add to the loads
+        load_vec = inputs["joint_axias_force"] * load_dir
+        outputs["loads_out"] = inputs["loads"] * 1.0
+        outputs["loads_out"][joint_idx, :3] += load_vec
+
+
+class JuryStrutRod(om.ExplicitComponent):
+    """
+    Analytic rod model for jury strut
+    """
+
+    def initialize(self):
+        self.options.declare("surface", types=dict)
+
+    def setup(self):
+        self.add_input("jury_nodes", val=np.zeros((2, 3)), units='m')
+        self.add_input("jury_A", val=1., units="m**2", desc="cross-sectional area of jury strut")
+        self.add_input("disp_jury", val=0., units='m', desc="axial displacement of jury strut (tension = positive)")
+
+        self.add_output("joint_axias_force", val=0., units="N", desc="axial force on jury joint. Positive = tension")
+
+        self.declare_partials("*", "*", method="cs", step=1e-100)
+
+    def compute(self, inputs, outputs):
+        surface = self.options["surface"]
+        E = surface["E"]
+
+        A = inputs["jury_A"]
+        jury_nodes = inputs["jury_nodes"]
+        disp = inputs["disp_jury"]
+
+        jury_len = np.linalg.norm(jury_nodes[-1, :] - jury_nodes[0, :])
+        outputs["joint_axias_force"] = E * A * disp / jury_len
+
+
+class JuryDispFromSBW(om.ExplicitComponent):
+    """
+    Compute jury strut displacement from the strut-braced wing FEM displacements
+    """
+    def setup(self):
+        self.add_input("disp_wing", shape=(3,), units='m')
+        self.add_input("disp_strut", shape=(3,), units='m')
+        self.add_input("jury_nodes", shape=(2, 3), units='m')
+        
+        self.add_output("disp_jury", val=0., units='m', desc="axial displacement of jury strut (tension = positive)")
+
+        self.declare_partials("*", "*", method="cs", step=1e-100)
+
+    def compute(self, inputs, outputs):
+        jury_nodes = inputs["jury_nodes"]
+        
+        # jury strut direction
+        jury_dir = jury_nodes[-1, :] - jury_nodes[0, :]
+        jury_dir = jury_dir / np.linalg.norm(jury_dir)
+
+        # compute jury strut tensile displacement
+        disp_wing_mapped = np.dot(inputs["disp_wing"], jury_dir)
+        disp_strut_mapped = np.dot(inputs["disp_strut"], jury_dir)
+        outputs["disp_jury"] = disp_strut_mapped - disp_wing_mapped
\ No newline at end of file

From c513559095fd0189c466387949a93865f00cfff2 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Mon, 18 Aug 2025 14:57:57 -0400
Subject: [PATCH 16/30] bugfix for conventional

---
 openaerostruct/functionals/total_performance.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/openaerostruct/functionals/total_performance.py b/openaerostruct/functionals/total_performance.py
index d14b0e7e8..2df5ba0cf 100644
--- a/openaerostruct/functionals/total_performance.py
+++ b/openaerostruct/functionals/total_performance.py
@@ -40,6 +40,9 @@ def setup(self):
                     raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
             else:
                 raise ValueError("surfaces must be in order of [wing_surface, strut_surface, (optional) jury_surface]")
+        else:
+            surfaces_all = surfaces
+            surfaces_AS = surfaces
 
         if not self.options["user_specified_Sref"]:
             self.add_subsystem(

From 0fe4a718df2d3ccd1ea75d52b76291135ef97db0 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Mon, 18 Aug 2025 17:20:40 -0400
Subject: [PATCH 17/30] minor fix for old python

---
 openaerostruct/integration/aerostruct_groups.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 95e230bb0..df07afee6 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -488,7 +488,7 @@ def setup(self):
                 promotes_inputs=["nodes", "Iz", "joint_load"],
                 promotes_outputs=["failure_column_buckling"]
             )
-            self.connect("coupled.FEM_SBW.joint_axias_force", f"{surface["name"]}_perf.joint_load")
+            self.connect("coupled.FEM_SBW.joint_axias_force", surface["name"] + "_perf.joint_load")
 
         # Add functionals to evaluate performance of the system.
         # Note that only the interesting results are promoted here; not all

From c609a34d875a33a4553dbad0954217e98dc29080 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Mon, 18 Aug 2025 17:28:54 -0400
Subject: [PATCH 18/30] more very minor fix

---
 openaerostruct/integration/aerostruct_groups.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index df07afee6..8357b95b7 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -474,14 +474,14 @@ def setup(self):
         # post-AS-analysis computations for structure-only components
         # for surface in [s for s in surfaces_all if s not in surfaces_AS]:
         #     self.add_subsystem(
-        #         f"{surface["name"]}_perf",
+        #         surface["name"] + "_perf",
         #         SpatialBeamFunctionals(surface=surface),
         #     )
 
         # column buckling failure for jury strut
         for surface in [s for s in surfaces_all if s not in surfaces_AS]:
             ny = surface["mesh"].shape[1]
-            perf_group = self.add_subsystem(f"{surface["name"]}_perf", om.Group())
+            perf_group = self.add_subsystem(surface["name"] + "_perf", om.Group())
             perf_group.add_subsystem(
                 "column_buckling",
                 EulerColumnBucklingFailureKS(surface=surface, ny=ny, joint_load_type="scaler"),

From 8fcacb29c17c5a07b16b1af334ad9e818767a4d5 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Tue, 26 Aug 2025 14:02:57 -0400
Subject: [PATCH 19/30] added column length factor for Euler buckling

---
 openaerostruct/integration/aerostruct_groups.py  | 6 +++---
 openaerostruct/structures/failure_buckling_ks.py | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 8357b95b7..d05e3be18 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -445,7 +445,7 @@ def setup(self):
                     # column buckling for outer strut segment. Use strut-wing joint load as a compression load
                     perf_group.add_subsystem(
                         "column_buckling_outer",
-                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_outer),
+                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_outer, column_length_factor=surface["column_length_factor_outer"]),
                         promotes_inputs=[("joint_load", "joint_load_strut_wing")],
                         promotes_outputs=[("failure_column_buckling", "failure_column_buckling_outer")]
                     )
@@ -455,7 +455,7 @@ def setup(self):
                     # column buckling for inner strut segment. Use strut-root reaction force as a compression load
                     perf_group.add_subsystem(
                         "column_buckling_inner",
-                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_inner),
+                        EulerColumnBucklingFailureKS(surface=surface, joint_load_type="vector", ny=ny_inner, column_length_factor=surface["column_length_factor_inner"]),
                         promotes_inputs=[("joint_load", "reaction_load_strut_root")],
                         promotes_outputs=[("failure_column_buckling", "failure_column_buckling_inner")]
                     )
@@ -466,7 +466,7 @@ def setup(self):
                     ny = surface["mesh"].shape[1]
                     perf_group.add_subsystem(
                         "column_buckling",
-                        EulerColumnBucklingFailureKS(surface=surface, ny=ny, joint_load_type="vector"),
+                        EulerColumnBucklingFailureKS(surface=surface, ny=ny, joint_load_type="vector", column_length_factor=surface["column_length_factor"]),
                         promotes_inputs=["nodes", "Iz", ("joint_load", "joint_load_strut_wing")],
                         promotes_outputs=["failure_column_buckling"]
                     )
diff --git a/openaerostruct/structures/failure_buckling_ks.py b/openaerostruct/structures/failure_buckling_ks.py
index b2f8dcadf..c0d3688f2 100644
--- a/openaerostruct/structures/failure_buckling_ks.py
+++ b/openaerostruct/structures/failure_buckling_ks.py
@@ -163,6 +163,7 @@ def initialize(self):
         self.options.declare("ny", desc="number of nodes in the strut")
         self.options.declare("rho", types=float, default=100.0, desc="KS aggregation smoothness parameter")
         self.options.declare("joint_load_type", types=str, default="vector", desc="type of joint load, either `vector` or `scaler`. If scaler, this should be the axial tension force")
+        self.options.declare("column_length_factor", types=float, default=1.0, desc="factor to multiply the strut length to account for e.g. mount")
 
     def setup(self):
         ny = self.options["ny"]
@@ -194,7 +195,7 @@ def compute(self, inputs, outputs):
         # strut length
         # The length we compute from the FEM nodes are longer than the actual length because e.g. we don't model fuselage so the strut root is at the symmetry plane.
         # To account for this, apply a factor < 1 to the strut length.
-        column_length_factor = self.options["surface"]["column_length_factor"]
+        column_length_factor = self.options["column_length_factor"]
         strut_len = np.linalg.norm(nodes[0, :] - nodes[-1, :]) * column_length_factor
 
         # compression load

From fc1cb4f4f96c71142825f719034806b26a031f84 Mon Sep 17 00:00:00 2001
From: Shugo Kaneko <49300827+kanekosh@users.noreply.github.com>
Date: Wed, 17 Sep 2025 23:42:06 -0400
Subject: [PATCH 20/30] Skip a failing test on OM 3.40 (#467)

* skip test

* set OM upper bound
---
 setup.py                                     | 3 ++-
 tests/integration_tests/test_multi_single.py | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index b8e4b45e0..cb2b35cba 100644
--- a/setup.py
+++ b/setup.py
@@ -54,7 +54,7 @@
     package_data={"openaerostruct": ["tests/*.py", "*/tests/*.py", "*/*/tests/*.py"]},
     install_requires=[
         # Remember to update the oldest versions in docs/installation.rst
-        "openmdao>=3.35",
+        "openmdao>=3.35,<=3.39",
         "numpy>=1.21",
         "scipy>=1.7",
         "matplotlib",
@@ -68,3 +68,4 @@
     plot_wingbox=openaerostruct.utils.plot_wingbox:disp_plot
     """,
 )
+
diff --git a/tests/integration_tests/test_multi_single.py b/tests/integration_tests/test_multi_single.py
index 3e2f805d5..f2cef9d20 100644
--- a/tests/integration_tests/test_multi_single.py
+++ b/tests/integration_tests/test_multi_single.py
@@ -1,7 +1,10 @@
 from openmdao.utils.assert_utils import assert_near_equal
 import unittest
 
+import openmdao
 
+# skip this test on OpenMDAO 3.40.0 because it fails due to a bug in OM 3.40.0
+@unittest.skipIf(openmdao.__version__ == "3.40.0", "Skipped on OpenMDAO 3.40.0")
 class Test(unittest.TestCase):
     def test(self):
         import numpy as np

From 33685eb564f66362d71bdf9c86b1b0a0f29db810 Mon Sep 17 00:00:00 2001
From: Shugo Kaneko <49300827+kanekosh@users.noreply.github.com>
Date: Thu, 18 Sep 2025 10:26:02 -0400
Subject: [PATCH 21/30] Switch to Ruff linting and formatting (#466)

* migrated local flake8 to ruff.toml

* add extend to ruff local configu

* whitespace fixes

* trigger checks

* Update ruff.toml configuration paths

* Update gitignore

* Automatic formatting changes

* Non-automatic fixes

* trigger build

* Trigger Build

* Formatting

---------

Co-authored-by: Alasdair Gray <alachris@umich.edu>
---
 .flake8                                       |   8 -
 .gitignore                                    |   3 +
 .readthedocs.yaml                             |   3 +-
 CITATION.cff                                  |   2 +-
 openaerostruct/aerodynamics/aero_groups.py    |   2 +-
 .../aerodynamics/compressible_states.py       |   1 +
 openaerostruct/aerodynamics/geometry.py       |   2 +-
 openaerostruct/aerodynamics/lift_drag.py      |   2 +-
 .../aerodynamics/mesh_point_forces.py         |   1 +
 openaerostruct/aerodynamics/total_drag.py     |   2 +-
 openaerostruct/aerodynamics/wave_drag.py      |   4 +-
 .../docs/_n2html/generate_n2_n2.html          |  54 +-
 openaerostruct/docs/_static/copybutton.js     |   4 +-
 .../advanced_features/custom_mesh_example.rst |   2 +-
 .../customizing_prob_setup.rst                |   2 +-
 .../docs/advanced_features/figs/CRM_esque.svg |   2 +-
 .../docs/advanced_features/figs/bspline.svg   |   2 +-
 .../docs/advanced_features/figs/chord.svg     |   2 +-
 .../docs/advanced_features/figs/dihedral.svg  |   2 +-
 .../figs/inverted_gull-wing.svg               |   2 +-
 .../advanced_features/figs/mesh-diagram.svg   |   2 +-
 .../docs/advanced_features/figs/radius.svg    |   2 +-
 .../docs/advanced_features/figs/sweep.svg     |   2 +-
 .../docs/advanced_features/figs/taper.svg     |   2 +-
 .../docs/advanced_features/figs/thickness.svg |   2 +-
 .../docs/advanced_features/figs/twist.svg     |   2 +-
 .../docs/advanced_features/figs/xshear.svg    |   2 +-
 .../docs/advanced_features/figs/zshear.svg    |   2 +-
 .../docs/advanced_features/ground_effect.rst  |   2 -
 .../docs/advanced_features/mphys_coupling.rst |   2 +-
 .../multi_section_surfaces.rst                |  34 +-
 .../docs/advanced_features/multipoint.rst     |   2 +-
 .../advanced_features/multipoint_parallel.rst |   8 +-
 .../openconcept_coupling.rst                  |   2 +-
 .../advanced_features/scripts/basic_2_sec.py  |   5 +-
 .../scripts/basic_2_sec_AS.py                 |   3 +-
 .../scripts/basic_2_sec_construction.py       |   5 +-
 .../scripts/basic_2_sec_visc.py               |   5 +-
 .../advanced_features/scripts/run_vsp_777.py  |   1 +
 openaerostruct/docs/aerostructural_index.rst  |   2 +-
 openaerostruct/docs/index.rst                 |   2 +-
 openaerostruct/docs/user_reference.rst        |   2 +-
 .../docs/user_reference/debugging_tips.rst    |   2 +-
 .../docs/user_reference/mesh_surface_dict.rst |  96 +-
 .../docs/user_reference/v1_v2_conversion.rst  |   2 +-
 openaerostruct/geometry/ffd_component.py      |   3 +-
 openaerostruct/geometry/geometry_mesh.py      |   2 +-
 .../geometry/geometry_mesh_transformations.py |   3 +-
 openaerostruct/geometry/radius_comp.py        |   2 +-
 .../integration/aerostruct_groups.py          |   2 +-
 .../meshing/section_mesh_generator.py         |   2 +-
 openaerostruct/mphys/mux_surface_forces.py    |   2 +-
 openaerostruct/structures/failure_ks.py       |   2 +-
 openaerostruct/structures/fuel_loads.py       |   4 -
 openaerostruct/structures/fuel_vol.py         |   2 +-
 .../structures/non_intersecting_thickness.py  |   2 +-
 .../structures/section_properties_tube.py     |   2 +-
 .../structures/section_properties_wingbox.py  |  20 +-
 openaerostruct/structures/spar_within_wing.py |   2 +-
 .../structures/spatial_beam_functionals.py    |   3 +-
 .../structures/spatial_beam_setup.py          |   3 +-
 openaerostruct/structures/structural_cg.py    |   2 +-
 openaerostruct/structures/vonmises_tube.py    |   2 +-
 openaerostruct/structures/weight.py           |   2 +-
 .../structures/wing_weight_loads.py           |   2 +-
 openaerostruct/utils/testing.py               |   6 +-
 ruff.toml                                     |  10 +
 setup.py                                      |   1 -
 ...est_aerostruct_wingbox_+weight_analysis.py |   1 -
 .../test_aerostruct_wingbox_analysis.py       |   1 -
 ...ostruct_wingbox_fuel_vol_constraint_opt.py | 887 ++++++++--------
 .../test_aerostruct_wingbox_opt.py            | 833 ++++++++--------
 ...ct_wingbox_wave_fuel_vol_constraint_opt.py | 881 ++++++++--------
 .../integration_tests/test_multi_2_sec_AS.py  |   3 +-
 tests/integration_tests/test_multi_single.py  |   1 +
 .../integration_tests/test_multi_single_AS.py |   3 +-
 .../test_multipoint_wingbox_aerostruct.py     |   1 -
 .../test_multipoint_wingbox_derivs.py         | 943 +++++++++---------
 .../test_wingbox_analysis.py                  |   1 -
 .../integration_tests/test_wingbox_derivs.py  | 921 +++++++++--------
 .../test_wingbox_distributed_fuel.py          |   1 -
 81 files changed, 2423 insertions(+), 2428 deletions(-)
 delete mode 100644 .flake8
 create mode 100644 ruff.toml

diff --git a/.flake8 b/.flake8
deleted file mode 100644
index 7dfa6ed49..000000000
--- a/.flake8
+++ /dev/null
@@ -1,8 +0,0 @@
-[flake8]
-# OpenAeroStruct-specific settings in addition to the MDO Lab standard config file.
-extend-exclude =
-    openaerostruct/docs/conf.py,
-    openaerostruct/docs/aero_walkthrough/part*.py,
-    openaerostruct/docs/_utils/docutil.py,
-    openaerostruct/docs/_utils/patch.py,
-    openaerostruct/utils/plot_*.py,
diff --git a/.gitignore b/.gitignore
index bf8c8aedf..8a939a13d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,9 @@
 # Ignore OpenMDAO reports folders
 **/reports/
 
+# pre-commit config file that should be manually copied from the mdolab/.github repo.
+.pre-commit-config.yaml
+
 *.pyc
 *.py~
 *.db
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index 4d7f9738a..1257c6976 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -11,8 +11,7 @@ build:
   tools:
     python: "3.11"
 
-sphinx:
-  configuration: openaerostruct/docs/conf.py
+
 
 python:
   install:
diff --git a/CITATION.cff b/CITATION.cff
index f696d8c71..aec49a916 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -28,4 +28,4 @@ preferred-citation:
   number: "4"
   pages: "1815--1827"
   date: "2018-04"
-  doi: "10.1007/s00158-018-1912-8"
\ No newline at end of file
+  doi: "10.1007/s00158-018-1912-8"
diff --git a/openaerostruct/aerodynamics/aero_groups.py b/openaerostruct/aerodynamics/aero_groups.py
index 0b5981d24..8e0ee2a1b 100644
--- a/openaerostruct/aerodynamics/aero_groups.py
+++ b/openaerostruct/aerodynamics/aero_groups.py
@@ -23,7 +23,7 @@ def initialize(self):
             "compressible",
             types=bool,
             default=False,
-            desc="Turns on compressibility correction for moderate Mach number " "flows. Defaults to False.",
+            desc="Turns on compressibility correction for moderate Mach number flows. Defaults to False.",
         )
 
     def setup(self):
diff --git a/openaerostruct/aerodynamics/compressible_states.py b/openaerostruct/aerodynamics/compressible_states.py
index 5e9cf29e6..308cc052c 100644
--- a/openaerostruct/aerodynamics/compressible_states.py
+++ b/openaerostruct/aerodynamics/compressible_states.py
@@ -1,6 +1,7 @@
 """
 Class definition for CompressibleVLMStates.
 """
+
 import openmdao.api as om
 
 from openaerostruct.aerodynamics.get_vectors import GetVectors
diff --git a/openaerostruct/aerodynamics/geometry.py b/openaerostruct/aerodynamics/geometry.py
index 91ceeae1c..e93a18a22 100644
--- a/openaerostruct/aerodynamics/geometry.py
+++ b/openaerostruct/aerodynamics/geometry.py
@@ -11,7 +11,7 @@ class VLMGeometry(om.ExplicitComponent):
     Some of the quantities, like `normals`, are used to compute the RHS
     of the AIC linear system.
 
-    parameters
+    Parameters
     ----------
     def_mesh[nx, ny, 3] : numpy array
         Array defining the nodal coordinates of the lifting surface.
diff --git a/openaerostruct/aerodynamics/lift_drag.py b/openaerostruct/aerodynamics/lift_drag.py
index a96615828..91fbae99c 100644
--- a/openaerostruct/aerodynamics/lift_drag.py
+++ b/openaerostruct/aerodynamics/lift_drag.py
@@ -8,7 +8,7 @@ class LiftDrag(om.ExplicitComponent):
     Calculate total lift and drag in force units based on section forces.
     This is for one given lifting surface.
 
-    parameters
+    Parameters
     ----------
     sec_forces[nx-1, ny-1, 3] : numpy array
         Contains the sectional forces acting on each panel.
diff --git a/openaerostruct/aerodynamics/mesh_point_forces.py b/openaerostruct/aerodynamics/mesh_point_forces.py
index 4699d58c7..0188b25e4 100644
--- a/openaerostruct/aerodynamics/mesh_point_forces.py
+++ b/openaerostruct/aerodynamics/mesh_point_forces.py
@@ -1,6 +1,7 @@
 """
 Class definition for the MeshPointForces component.
 """
+
 import numpy as np
 import openmdao.api as om
 
diff --git a/openaerostruct/aerodynamics/total_drag.py b/openaerostruct/aerodynamics/total_drag.py
index 38fef9103..9b5e3ff63 100644
--- a/openaerostruct/aerodynamics/total_drag.py
+++ b/openaerostruct/aerodynamics/total_drag.py
@@ -4,7 +4,7 @@
 class TotalDrag(om.ExplicitComponent):
     """Calculate total drag in force units.
 
-    parameters
+    Parameters
     ----------
     CDi : float
         Induced coefficient of drag (CD) for the lifting surface.
diff --git a/openaerostruct/aerodynamics/wave_drag.py b/openaerostruct/aerodynamics/wave_drag.py
index 0b58e6b22..2b013d1f3 100644
--- a/openaerostruct/aerodynamics/wave_drag.py
+++ b/openaerostruct/aerodynamics/wave_drag.py
@@ -126,9 +126,7 @@ def compute_partials(self, inputs, partials):
                 ccos = np.sum(widths * panel_mid_chords)
                 ccos2w = np.sum(panel_mid_chords * widths**2 / lengths_spanwise)
 
-                davgdcos = (
-                    2 * panel_mid_chords * widths / lengths_spanwise / ccos - panel_mid_chords * ccos2w / ccos**2
-                )
+                davgdcos = 2 * panel_mid_chords * widths / lengths_spanwise / ccos - panel_mid_chords * ccos2w / ccos**2
                 dtocdcos = (
                     panel_mid_chords * t_over_c / ccos
                     - panel_mid_chords * np.sum(panel_mid_chords * widths * t_over_c) / ccos**2
diff --git a/openaerostruct/docs/_n2html/generate_n2_n2.html b/openaerostruct/docs/_n2html/generate_n2_n2.html
index 11ce9d1b5..129601531 100644
--- a/openaerostruct/docs/_n2html/generate_n2_n2.html
+++ b/openaerostruct/docs/_n2html/generate_n2_n2.html
@@ -356,7 +356,7 @@
     /* transition: opacity 0.25s; */
     box-shadow: 3px 3px 3px 1px rgba(0, 0, 0, 0.2);
     border-radius: 10px;
-    
+
     overflow: hidden;
 }
 
@@ -487,7 +487,7 @@
 .window-theme-value-info .window-body table tbody tr td {
     text-align: left;
     font-size: 9pt;
-    margin: 0;    
+    margin: 0;
     border-top: 0;
     border-left: 0;
     border-bottom: 1px solid #a0a0a0;
@@ -507,7 +507,7 @@
 .show_value_button {
     background-color: #c1c1c1;
  }
- 
+
  .copy_value_button {
     background-color: #c1c1c1;
  }
@@ -2858,7 +2858,7 @@ <h1>Toolbar Help</h1>
 </script>
      <script type="text/javascript">
 (function(e){if(typeof exports=="object"&&typeof module!="undefined")module.exports=
-e();else if(typeof define=="function"&&define.amd)define([],e);else{var t;typeof 
+e();else if(typeof define=="function"&&define.amd)define([],e);else{var t;typeof
 window!="undefined"?t=window:typeof global!="undefined"?t=global:typeof self!="undefined"?
 t=self:t=this,t.pako=e()}})(function(){var e,t,n;return function(){function e(t,
 n,i){function s(u,a){if(!n[u]){if(!t[u]){var f="function"==typeof require&&require
@@ -2867,7 +2867,7 @@ <h1>Toolbar Help</h1>
 exports,function(e){var n=t[u][1][e];return s(n||e)},c,c.exports,e,t,n,i)}return n
 [u].exports}for(var o="function"==typeof require&&require,u=0;u<i.length;u++)s(i
 [u]);return s}return e}()({1:[function(e,t,n){"use strict";function i(e,t){return Object
-.prototype.hasOwnProperty.call(e,t)}var r=typeof Uint8Array!="undefined"&&typeof 
+.prototype.hasOwnProperty.call(e,t)}var r=typeof Uint8Array!="undefined"&&typeof
 Uint16Array!="undefined"&&typeof Int32Array!="undefined";n.assign=function(e){var t=
 Array.prototype.slice.call(arguments,1);while(t.length){var n=t.shift();if(!n)continue;
 if(typeof n!="object")throw new TypeError(n+"must be non-object");for(var r in n
@@ -2947,7 +2947,7 @@ <h1>Toolbar Help</h1>
 this.work=new r.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0
 ,this.was=0}function ot(e){var t;return!e||!e.state?g:(t=e.state,e.total_in=e.total_out=
 t.total=0,e.msg="",t.wrap&&(e.adler=t.wrap&1),t.mode=S,t.last=0,t.havedict=0,t.dmax=32768
-,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new r.Buf32(et),t.distcode=t.distdyn=new 
+,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new r.Buf32(et),t.distcode=t.distdyn=new
 r.Buf32(tt),t.sane=1,t.back=-1,d)}function ut(e){var t;return!e||!e.state?g:(t=e
 .state,t.wsize=0,t.whave=0,t.wnext=0,ot(e))}function at(e,t){var n,r;return!e||!
 e.state?g:(r=e.state,t<0?(n=0,t=-t):(n=(t>>4)+1,t<48&&(t&=15)),t&&(t<8||t>15)?g:
@@ -2958,12 +2958,12 @@ <h1>Toolbar Help</h1>
 ;while(t<280)e.lens[t++]=7;while(t<288)e.lens[t++]=8;u(f,e.lens,0,288,ht,0,e.work
 ,{bits:9}),t=0;while(t<32)e.lens[t++]=5;u(l,e.lens,0,32,pt,0,e.work,{bits:5}),ct=!1
 }e.lencode=ht,e.lenbits=9,e.distcode=pt,e.distbits=5}function vt(e,t,n,i){var s,
-o=e.state;return o.window===null&&(o.wsize=1<<o.wbits,o.wnext=0,o.whave=0,o.window=new 
+o=e.state;return o.window===null&&(o.wsize=1<<o.wbits,o.wnext=0,o.whave=0,o.window=new
 r.Buf8(o.wsize)),i>=o.wsize?(r.arraySet(o.window,t,n-o.wsize,o.wsize,0),o.wnext=0
 ,o.whave=o.wsize):(s=o.wsize-o.wnext,s>i&&(s=i),r.arraySet(o.window,t,n-i,s,o.wnext
 ),i-=s,i?(r.arraySet(o.window,t,n-i,i,0),o.wnext=i,o.whave=o.wsize):(o.wnext+=s,
 o.wnext===o.wsize&&(o.wnext=0),o.whave<o.wsize&&(o.whave+=s))),0}function mt(e,t
-){var n,et,tt,nt,rt,st,ot,ut,at,ft,lt,ct,ht,pt,mt=0,gt,yt,bt,wt,Et,St,xt,Tt,Nt=new 
+){var n,et,tt,nt,rt,st,ot,ut,at,ft,lt,ct,ht,pt,mt=0,gt,yt,bt,wt,Et,St,xt,Tt,Nt=new
 r.Buf8(4),Ct,kt,Lt=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];if(!e||!e.state||!
 e.output||!e.input&&e.avail_in!==0)return g;n=e.state,n.mode===D&&(n.mode=P),rt=
 e.next_out,tt=e.output,ot=e.avail_out,nt=e.next_in,et=e.input,st=e.avail_in,ut=n
@@ -3112,7 +3112,7 @@ <h1>Toolbar Help</h1>
 }},{}],11:[function(e,t,n){"use strict";function r(){this.input=null,this.next_in=0
 ,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0
 ,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}t.exports=
-r},{}],"/lib/inflate.js":[function(e,t,n){"use strict";function c(e){if(!(this instanceof 
+r},{}],"/lib/inflate.js":[function(e,t,n){"use strict";function c(e){if(!(this instanceof
 c))return new c(e);this.options=i.assign({chunkSize:16384,windowBits:0,to:""},e||
 {});var t=this.options;t.raw&&t.windowBits>=0&&t.windowBits<16&&(t.windowBits=-t
 .windowBits,t.windowBits===0&&(t.windowBits=-15)),t.windowBits>=0&&t.windowBits<16&&
@@ -3121,7 +3121,7 @@ <h1>Toolbar Help</h1>
 .strm=new a,this.strm.avail_out=0;var n=r.inflateInit2(this.strm,t.windowBits);if(
 n!==o.Z_OK)throw new Error(u[n]);this.header=new f,r.inflateGetHeader(this.strm,
 this.header);if(t.dictionary){typeof t.dictionary=="string"?t.dictionary=s.string2buf
-(t.dictionary):l.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new 
+(t.dictionary):l.call(t.dictionary)==="[object ArrayBuffer]"&&(t.dictionary=new
 Uint8Array(t.dictionary));if(t.raw){n=r.inflateSetDictionary(this.strm,t.dictionary
 );if(n!==o.Z_OK)throw new Error(u[n])}}}function h(e,t){var n=new c(t);n.push(e,!0
 );if(n.err)throw n.msg||u[n.err];return n.result}function p(e,t){return t=t||{},
@@ -3219,7 +3219,7 @@ <h1>Toolbar Help</h1>
 });
 
 /**
- * Since checking for an Array's existance as well as 
+ * Since checking for an Array's existance as well as
  * length > 0 is very common, combine the two.
  */
 Array.isPopulatedArray = function (arr) {
@@ -3330,7 +3330,7 @@ <h1>Toolbar Help</h1>
         }
     }
 
-    /** 
+    /**
      * Decide what object the cell will be drawn as, based on its position
      * in the matrix, type, source, target, and/or other conditions.
      * @param {N2MatrixCell} cell The cell to operate on.
@@ -3728,13 +3728,13 @@ <h1>Toolbar Help</h1>
     static uncompressModel(b64str) {
         const compressedData = atob(b64str);
         const jsonStr = window.pako.inflate(compressedData, { to: 'string' });
-            
+
         /* for ( let pos = 0; pos < jsonStr.length; pos += 100) {
             console.log(pos, jsonStr.substring(pos, pos+99));
         } */
 
         // JSON5 can handle Inf and NaN
-        return JSON5.parse(jsonStr); 
+        return JSON5.parse(jsonStr);
     }
 
     /**
@@ -4882,7 +4882,7 @@ <h1>Toolbar Help</h1>
             this.bringToFront(true, 2);
             modalDiv.attr('style', style)
                 .style('z-index', N2Window.zIndex - 1)
-                
+
         }
         else {
             modalDiv.attr('style', null);
@@ -5007,7 +5007,7 @@ <h1>Toolbar Help</h1>
         this.header.style('cursor', cursor);
         this.window.style('cursor', cursor);
         this.window.select('.window-close-button').style('cursor', cursor);
-        this.resizerDiv.selectAll('div').style('cursor', cursor);        
+        this.resizerDiv.selectAll('div').style('cursor', cursor);
 
         return this;
     }
@@ -5867,7 +5867,7 @@ <h1>Toolbar Help</h1>
             .attr("ry", dims.bottomRight.y * .6);
     }
 
-    /** 
+    /**
      * Get the D3 selection for the appropriate group and append a filled ellipse.
      * @param {Object} svgGroup Reference to SVG <g> element associated with data.
      * @param {Object} dims The cell spec to use while rendering.
@@ -5916,7 +5916,7 @@ <h1>Toolbar Help</h1>
         return ret;
     }
 
-    /** 
+    /**
      * Get the D3 selection for the appropriate group and append a filled rectangle.
      * @param {Object} svgGroup Reference to SVG <g> element associated with data.
      * @param {Object} dims The cell spec to use while rendering.
@@ -5960,7 +5960,7 @@ <h1>Toolbar Help</h1>
         return ret;
     }
 
-    /** 
+    /**
      * Get the D3 selection for the appropriate group and append a filled arrow.
      * @param {Object} svgGroup Reference to SVG <g> element associated with data.
      * @param {Object} dims The cell spec to use while rendering.
@@ -6062,7 +6062,7 @@ <h1>Toolbar Help</h1>
             .attr("height", dims.size.height * .6);
     }
 
-    /** 
+    /**
      * Get the D3 selection for the appropriate group and append a filled rectangle,
      * then call _renderBorder() to put a border around it.
      * @param {Object} svgGroup Reference to SVG <g> element associated with data.
@@ -6218,7 +6218,7 @@ <h1>Toolbar Help</h1>
 
     static makeId(srcId, tgtId = null) {
         if (! tgtId || srcId == tgtId) return "node_" + srcId;
-        
+
         return "conn_" + srcId + "_to_" + tgtId;
     }
 
@@ -6886,7 +6886,7 @@ <h1>Toolbar Help</h1>
      */
     findCellByNodeId(nodeId) {
         const node = this.model.nodeIds[nodeId];
-        let ret = { 
+        let ret = {
             'cell': undefined,    // Changed to refer to a related cell if found
             'exactMatch': false,  // True if nodeId matches a cell
             'parentMatch': false, // True if nodeId's ancestor is a cell
@@ -6925,7 +6925,7 @@ <h1>Toolbar Help</h1>
                 return ret;
             }
         }
-    
+
         // Shouldn't really get here due to zoomedElement check at top
         debugInfo(`findCellByNodeId: ${debugStr} fell through all checks!`)
         return ret;
@@ -10661,7 +10661,7 @@ <h1>Toolbar Help</h1>
 }
 
 /**
- * Output a message if the value is True. 
+ * Output a message if the value is True.
  * @typedef InfoPropMessage
  */
 class InfoPropMessage extends InfoPropYesNo {
@@ -10671,8 +10671,8 @@ <h1>Toolbar Help</h1>
     }
 
     /** Return message when value is True */
-    output(boolVal) { 
-        return boolVal ? this.message : ''; 
+    output(boolVal) {
+        return boolVal ? this.message : '';
     }
 }
 
@@ -11072,7 +11072,7 @@ <h1>Toolbar Help</h1>
     /** Toggle the active mode */
     toggle() {
         if (this.active) return this.deactivate();
-        
+
         return this.activate();
     }
 
diff --git a/openaerostruct/docs/_static/copybutton.js b/openaerostruct/docs/_static/copybutton.js
index 16244343c..0a7db6d6d 100644
--- a/openaerostruct/docs/_static/copybutton.js
+++ b/openaerostruct/docs/_static/copybutton.js
@@ -2,11 +2,11 @@
 $(document).ready(function() {
     /* Add a [>>>] button on the top-right corner of code samples to hide
      * the >>> and ... prompts and the output and thus make the code
-     * copyable. 
+     * copyable.
      * Note: This JS snippet was taken from the official python.org
      * documentation site.*/
     var div = $('.highlight-python .highlight,' +
-                '.highlight-python3 .highlight,' + 
+                '.highlight-python3 .highlight,' +
                 '.highlight-pycon .highlight')
     var pre = div.find('pre');
 
diff --git a/openaerostruct/docs/advanced_features/custom_mesh_example.rst b/openaerostruct/docs/advanced_features/custom_mesh_example.rst
index e2d72cd87..7bc767820 100644
--- a/openaerostruct/docs/advanced_features/custom_mesh_example.rst
+++ b/openaerostruct/docs/advanced_features/custom_mesh_example.rst
@@ -26,4 +26,4 @@ Make sure you go through the :ref:`Aerostructural_with_Wingbox_Walkthrough` befo
    :layout: interleave
 
 There is plenty of room for improvement.
-A finer mesh and a tighter optimization tolerance should be used.
\ No newline at end of file
+A finer mesh and a tighter optimization tolerance should be used.
diff --git a/openaerostruct/docs/advanced_features/customizing_prob_setup.rst b/openaerostruct/docs/advanced_features/customizing_prob_setup.rst
index dcc06b4c1..41633f29e 100644
--- a/openaerostruct/docs/advanced_features/customizing_prob_setup.rst
+++ b/openaerostruct/docs/advanced_features/customizing_prob_setup.rst
@@ -23,4 +23,4 @@ Next, a new independent variable called ``S_ref_total`` needs to be created in t
 .. code-block:: python
 
   indep_var_comp.add_output('S_ref_total', val=areaRef, units='m**2')
-  prob.model.connect('S_ref_total', point_name + '.S_ref_total')
\ No newline at end of file
+  prob.model.connect('S_ref_total', point_name + '.S_ref_total')
diff --git a/openaerostruct/docs/advanced_features/figs/CRM_esque.svg b/openaerostruct/docs/advanced_features/figs/CRM_esque.svg
index f8309a7eb..0690792bb 100644
--- a/openaerostruct/docs/advanced_features/figs/CRM_esque.svg
+++ b/openaerostruct/docs/advanced_features/figs/CRM_esque.svg
@@ -114,4 +114,4 @@
                          d="m 577.668,506.676 29.059,-7.403"
                          style="fill:none;stroke:#000000;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
                          id="path64"
-                         inkscape:connector-curvature="0" /></g></g></g></g></g></g></g></g></g></g></svg>
\ No newline at end of file
+                         inkscape:connector-curvature="0" /></g></g></g></g></g></g></g></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/bspline.svg b/openaerostruct/docs/advanced_features/figs/bspline.svg
index ca1bb3bdd..1ca3e0a02 100644
--- a/openaerostruct/docs/advanced_features/figs/bspline.svg
+++ b/openaerostruct/docs/advanced_features/figs/bspline.svg
@@ -298,4 +298,4 @@
          id="path3241" /><path
          d="m 90,506.88 558,0"
          style="fill:none;stroke:#808080;stroke-opacity:1;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:10;stroke-dasharray:none"
-         id="path3243" /></g></g></svg>
\ No newline at end of file
+         id="path3243" /></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/chord.svg b/openaerostruct/docs/advanced_features/figs/chord.svg
index d009a9e8a..8f70bf11a 100644
--- a/openaerostruct/docs/advanced_features/figs/chord.svg
+++ b/openaerostruct/docs/advanced_features/figs/chord.svg
@@ -270,4 +270,4 @@
            id="path3265" /><path
            d="m 1174.343,522.87564 8.8664,-2.20707 8.8892,-2.21274"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3267" /></g></g></g></svg>
\ No newline at end of file
+           id="path3267" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/dihedral.svg b/openaerostruct/docs/advanced_features/figs/dihedral.svg
index fb7451c68..4193108c8 100644
--- a/openaerostruct/docs/advanced_features/figs/dihedral.svg
+++ b/openaerostruct/docs/advanced_features/figs/dihedral.svg
@@ -270,4 +270,4 @@
            id="path3605" /><path
            d="m 1179.1207,589.232 36.0503,-8.62232 36.4276,-8.71254"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3607" /></g></g></g></svg>
\ No newline at end of file
+           id="path3607" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/inverted_gull-wing.svg b/openaerostruct/docs/advanced_features/figs/inverted_gull-wing.svg
index f220bd633..dc6b55e52 100644
--- a/openaerostruct/docs/advanced_features/figs/inverted_gull-wing.svg
+++ b/openaerostruct/docs/advanced_features/figs/inverted_gull-wing.svg
@@ -205,4 +205,4 @@
                          id="path3134" /><path
                          d="M 484.168,553 550.18,536.871"
                          style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-                         id="path3136" /></g></g></g></g></g></g></g></g></g></g></svg>
\ No newline at end of file
+                         id="path3136" /></g></g></g></g></g></g></g></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/mesh-diagram.svg b/openaerostruct/docs/advanced_features/figs/mesh-diagram.svg
index 8986323ab..246021e65 100644
--- a/openaerostruct/docs/advanced_features/figs/mesh-diagram.svg
+++ b/openaerostruct/docs/advanced_features/figs/mesh-diagram.svg
@@ -187,4 +187,4 @@
                  y="0"
                  sodipodi:role="line"
                  id="tspan3184">increasing i</tspan></text>
-</g></g></g></g></g></svg>
\ No newline at end of file
+</g></g></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/radius.svg b/openaerostruct/docs/advanced_features/figs/radius.svg
index 8ad299f28..d7fe3d6f2 100644
--- a/openaerostruct/docs/advanced_features/figs/radius.svg
+++ b/openaerostruct/docs/advanced_features/figs/radius.svg
@@ -1652,4 +1652,4 @@
            id="path4218" /><path
            d="m 778.6624,153.05271 26.04082,21.91736 -8.77549,10.56833 -26.13712,-21.80838 8.87179,-10.67731 z"
            style="fill:#ae9f19;fill-opacity:1;fill-rule:nonzero;stroke:none"
-           id="path4220" /></g></g></g></svg>
\ No newline at end of file
+           id="path4220" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/sweep.svg b/openaerostruct/docs/advanced_features/figs/sweep.svg
index 331a77c79..90936403f 100644
--- a/openaerostruct/docs/advanced_features/figs/sweep.svg
+++ b/openaerostruct/docs/advanced_features/figs/sweep.svg
@@ -270,4 +270,4 @@
            id="path3945" /><path
            d="m 1239.2294,506.72376 36.2748,-9.02972 36.6533,-9.12397"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3947" /></g></g></g></svg>
\ No newline at end of file
+           id="path3947" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/taper.svg b/openaerostruct/docs/advanced_features/figs/taper.svg
index 1d66c3577..9de72265f 100644
--- a/openaerostruct/docs/advanced_features/figs/taper.svg
+++ b/openaerostruct/docs/advanced_features/figs/taper.svg
@@ -270,4 +270,4 @@
            id="path3775" /><path
            d="m 1205.7145,515.06648 7.1557,-1.78125 7.1705,-1.78492"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3777" /></g></g></g></svg>
\ No newline at end of file
+           id="path3777" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/thickness.svg b/openaerostruct/docs/advanced_features/figs/thickness.svg
index c564bfdd3..67b620f45 100644
--- a/openaerostruct/docs/advanced_features/figs/thickness.svg
+++ b/openaerostruct/docs/advanced_features/figs/thickness.svg
@@ -1652,4 +1652,4 @@
            id="path5436" /><path
            d="m 770.13119,149.80813 26.06692,21.89821 -4.18057,5.03383 -26.11269,-21.84644 4.22634,-5.0856 z"
            style="fill:#719625;fill-opacity:1;fill-rule:nonzero;stroke:none"
-           id="path5438" /></g></g></g></svg>
\ No newline at end of file
+           id="path5438" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/twist.svg b/openaerostruct/docs/advanced_features/figs/twist.svg
index f98dbfddc..732f6d1a1 100644
--- a/openaerostruct/docs/advanced_features/figs/twist.svg
+++ b/openaerostruct/docs/advanced_features/figs/twist.svg
@@ -270,4 +270,4 @@
            id="path3435" /><path
            d="m 1179.4393,529.1677 35.6996,-8.84759 36.0695,-8.93925"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3437" /></g></g></g></svg>
\ No newline at end of file
+           id="path3437" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/xshear.svg b/openaerostruct/docs/advanced_features/figs/xshear.svg
index 5cae2abea..ec94dc7f4 100644
--- a/openaerostruct/docs/advanced_features/figs/xshear.svg
+++ b/openaerostruct/docs/advanced_features/figs/xshear.svg
@@ -270,4 +270,4 @@
            id="path3949" /><path
            d="m 1144.1865,530.38238 35.2921,-8.78511 35.6554,-8.87555"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3951" /></g></g></g></svg>
\ No newline at end of file
+           id="path3951" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/figs/zshear.svg b/openaerostruct/docs/advanced_features/figs/zshear.svg
index c42b070f6..2a7824106 100644
--- a/openaerostruct/docs/advanced_features/figs/zshear.svg
+++ b/openaerostruct/docs/advanced_features/figs/zshear.svg
@@ -270,4 +270,4 @@
            id="path3779" /><path
            d="m 1176.3008,488.76813 35.4244,-8.99002 35.7886,-9.08249"
            style="fill:none;stroke:#000000;stroke-opacity:1;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none"
-           id="path3781" /></g></g></g></svg>
\ No newline at end of file
+           id="path3781" /></g></g></g></svg>
diff --git a/openaerostruct/docs/advanced_features/ground_effect.rst b/openaerostruct/docs/advanced_features/ground_effect.rst
index ac19e6a84..04029f384 100644
--- a/openaerostruct/docs/advanced_features/ground_effect.rst
+++ b/openaerostruct/docs/advanced_features/ground_effect.rst
@@ -39,5 +39,3 @@ These results are consistent with published values in the literature, for exampl
 
 .. image:: /advanced_features/figs/ground_effect_polars.png
     :width: 600
-
-
diff --git a/openaerostruct/docs/advanced_features/mphys_coupling.rst b/openaerostruct/docs/advanced_features/mphys_coupling.rst
index c675e6912..b0fba2c74 100644
--- a/openaerostruct/docs/advanced_features/mphys_coupling.rst
+++ b/openaerostruct/docs/advanced_features/mphys_coupling.rst
@@ -22,4 +22,4 @@ The example couples pyGeo's OpenVSP parameterization with OpenAeroStruct's aerod
 The interface will also write out aerodynamic solutions in a ``.plt`` file format that can open and viewed in TecPlot.
 
 .. embed-code::
-   advanced_features/scripts/mphys_opt_chord.py
\ No newline at end of file
+   advanced_features/scripts/mphys_opt_chord.py
diff --git a/openaerostruct/docs/advanced_features/multi_section_surfaces.rst b/openaerostruct/docs/advanced_features/multi_section_surfaces.rst
index ea72ce81c..903ab6d0b 100644
--- a/openaerostruct/docs/advanced_features/multi_section_surfaces.rst
+++ b/openaerostruct/docs/advanced_features/multi_section_surfaces.rst
@@ -3,9 +3,9 @@
 Multi-section surfaces for aerodynamic problems
 ==========================
 
-OpenAeroStruct features the ability to specify surfaces as a series of sequentially connected sections. 
-Rather than controling the geometry of the surface as a whole, the optimizer can control the geometric parameters of each section individually using any of the geometric transformations available in OpenAeroStruct. 
-This feature was developed for the modular wing morphing applications but can be useful in situations where the user wishes to optimize a particular wing section while leaving the others fixed. 
+OpenAeroStruct features the ability to specify surfaces as a series of sequentially connected sections.
+Rather than controling the geometry of the surface as a whole, the optimizer can control the geometric parameters of each section individually using any of the geometric transformations available in OpenAeroStruct.
+This feature was developed for the modular wing morphing applications but can be useful in situations where the user wishes to optimize a particular wing section while leaving the others fixed.
 
 This example script demonstrate the usage of the multi-section wing geometry features in OpenAeroStruct.
 We first start with the induced drag minimization of a simple two-section symmetrical wing.
@@ -30,22 +30,22 @@ Next, we setup the flow variables.
    :end-before: checkpoint 3
 
 
-Giving the optimizer control of each wing section without any measure to constrain them can lead to undesirable geometries, such as wing sections separating from each other or large kinks appearing along the span, that cause numerical deficiencies in the optimization. 
-This concern is addressed by enforcing C0 continuity along the span-wise junctions between the sections. 
-C0 continuity can be enforced for any geometric parameter OAS controls for a given section. 
-For example, the tip chord or twist of a given section should match the root chord or twist of the subsequent section. 
-There are two approaches for enforcing C0 continuity between sections: a construction-based approach and a constraint-based approach. 
+Giving the optimizer control of each wing section without any measure to constrain them can lead to undesirable geometries, such as wing sections separating from each other or large kinks appearing along the span, that cause numerical deficiencies in the optimization.
+This concern is addressed by enforcing C0 continuity along the span-wise junctions between the sections.
+C0 continuity can be enforced for any geometric parameter OAS controls for a given section.
+For example, the tip chord or twist of a given section should match the root chord or twist of the subsequent section.
+There are two approaches for enforcing C0 continuity between sections: a construction-based approach and a constraint-based approach.
 
-The constaint-based approach involves explicitly setting a position constraint that joins the surface points at section junctions to a specified tolerance. 
+The constaint-based approach involves explicitly setting a position constraint that joins the surface points at section junctions to a specified tolerance.
 This constraint is useful if the user desires a high degree of customization in how section are attached to each other.
 The number of linear constraints can quickly grow for problems with many sections.
 By reducing the degree of customization in section attachment, it is possible to eliminate these additional constraints and maintain C0 continuity using the construction-based approach.
 The remainder of this section describes the construction-based approach while the constraint-based approach is described in the subsequent section.
 
 
-Continuity by construction is enforced by assigning the B-spline control points located at section edges to the same independent variable controlled by the optimizer. 
-Enforcing C0 continuity by construction applies to geometric parameters that employ B-spline parametrization in OAS. 
-These include chord distribution, twist distribution, shear distribution in all three directions, and thickness and radius distributions for structural spars. 
+Continuity by construction is enforced by assigning the B-spline control points located at section edges to the same independent variable controlled by the optimizer.
+Enforcing C0 continuity by construction applies to geometric parameters that employ B-spline parametrization in OAS.
+These include chord distribution, twist distribution, shear distribution in all three directions, and thickness and radius distributions for structural spars.
 
 
 .. literalinclude:: /advanced_features/scripts/basic_2_sec_construction.py
@@ -57,7 +57,7 @@ The multi-section unification component built into the multi-section geometry gr
 This shifting is able to keep the sections together during span, sweep, and dihedral changes at the leading edge but enforcing full C0 continuity may still require the construction based approach described above.
 
 .. note::
-  Mesh shifting cannot compensate for taper transformations. 
+  Mesh shifting cannot compensate for taper transformations.
   Instead, the constraint-based approach should be used with the scaler taper variable.
   Alternatively, the effect of linear taper can be emulated by using two chord B-spline control points.
 
@@ -66,7 +66,7 @@ This shifting is able to keep the sections together during span, sweep, and dihe
    It is advised to disable mesh shifting by passing the following option into the multi-section geometery group.
 
    .. code-block:: python
-      
+
       shift_uni_mesh = False
 
 
@@ -103,7 +103,7 @@ We then finish by plotting the result.
    :end-before: checkpoint 8
 
 
-The following shows the resulting optimized mesh. 
+The following shows the resulting optimized mesh.
 The result is identical regardless of if the constraint-based or construction-based joining approahces are used.
 
 .. image:: /advanced_features/figs/multi_section_2_sym.png
@@ -114,7 +114,7 @@ Constraint-based Approach
 
 Setting up the multi-section goemetry group with the constrint-based approach for section joining requires a slightly different inital setup.
 The constraint can be enforced at the leading and/or trailing edge of each segment junction in any combination of x, y, or z directions.
-A fully differentiated implementation that facilitates setting this constraint is incorporated into OAS. This approach is robust but introduces at least two linear constraints per segment junction. 
+A fully differentiated implementation that facilitates setting this constraint is incorporated into OAS. This approach is robust but introduces at least two linear constraints per segment junction.
 The steps required to setup the multi-section geometry group by constraint feature differences from the construction-based approach starting at the geometry group setup.
 
 
@@ -169,4 +169,4 @@ Lastly, we plot and print the results.
 
 .. literalinclude:: /advanced_features/scripts/basic_2_sec_AS.py
    :start-after: checkpoint 5
-   :end-before: checkpoint 6
\ No newline at end of file
+   :end-before: checkpoint 6
diff --git a/openaerostruct/docs/advanced_features/multipoint.rst b/openaerostruct/docs/advanced_features/multipoint.rst
index b63384b13..99c1df1db 100644
--- a/openaerostruct/docs/advanced_features/multipoint.rst
+++ b/openaerostruct/docs/advanced_features/multipoint.rst
@@ -31,4 +31,4 @@ The following shows a visualization of the results.
 As can be seen, there is plenty of room for improvement.
 A finer mesh and a tighter optimization tolerance should be used.
 
-.. image:: /advanced_features/figs/wingbox_Q400.png
\ No newline at end of file
+.. image:: /advanced_features/figs/wingbox_Q400.png
diff --git a/openaerostruct/docs/advanced_features/multipoint_parallel.rst b/openaerostruct/docs/advanced_features/multipoint_parallel.rst
index ab3f08545..5faf4c6b2 100644
--- a/openaerostruct/docs/advanced_features/multipoint_parallel.rst
+++ b/openaerostruct/docs/advanced_features/multipoint_parallel.rst
@@ -17,7 +17,7 @@ We first import MPI.
 If this line does not work, make sure that you have a working MPI installation.
 
 .. code-block::
-    
+
     from mpi4py import MPI
 
 You may need to turn off the numpy multithreading.
@@ -32,9 +32,9 @@ The name of environment variable may be different depending on the system.
 Then, let's set up the problem in the same way as the serial runscript.
 
 .. code-block::
-    
+
     prob = om.Problem()
-    
+
     # Setup problem information in indep_var_comp
     ...
 
@@ -227,6 +227,6 @@ The actual speedup you can get depends on your problem setups, such as number of
    * - Serial
      - 1.451
      - 5.775
-   * - Parallel 
+   * - Parallel
      - 0.840
      - 4.983
diff --git a/openaerostruct/docs/advanced_features/openconcept_coupling.rst b/openaerostruct/docs/advanced_features/openconcept_coupling.rst
index 49c497459..19d2dfee6 100644
--- a/openaerostruct/docs/advanced_features/openconcept_coupling.rst
+++ b/openaerostruct/docs/advanced_features/openconcept_coupling.rst
@@ -6,4 +6,4 @@ Integrating Mission Analysis
 You can perform aerodynamic or aerostructural wing design optimization considering full mission analysis by integrating OpenAeroStruct with `OpenConcept <https://github.com/mdolab/openconcept>`_.
 OpenConcept is a toolkit for aircraft conceptual design, which is also built on top of the OpenMDAO framework.
 
-Examples of the OpenAeroStruct-OpenConcept coupled work can be found in OpenConcept `repository <https://github.com/mdolab/openconcept>`_ and `documentation <https://mdolab-openconcept.readthedocs-hosted.com/en/latest/>`_.
\ No newline at end of file
+Examples of the OpenAeroStruct-OpenConcept coupled work can be found in OpenConcept `repository <https://github.com/mdolab/openconcept>`_ and `documentation <https://mdolab-openconcept.readthedocs-hosted.com/en/latest/>`_.
diff --git a/openaerostruct/docs/advanced_features/scripts/basic_2_sec.py b/openaerostruct/docs/advanced_features/scripts/basic_2_sec.py
index 56d4b69b7..0d637e891 100644
--- a/openaerostruct/docs/advanced_features/scripts/basic_2_sec.py
+++ b/openaerostruct/docs/advanced_features/scripts/basic_2_sec.py
@@ -1,5 +1,6 @@
 """Optimizes the section chord distribution of a two section symmetrical wing using the constraint-based approach for section
-joining. This example is referenced as part of the multi-section tutorial."""
+joining. This example is referenced as part of the multi-section tutorial.
+"""
 
 # docs checkpoint 0
 import numpy as np
@@ -211,7 +212,7 @@
 
 # Plot the results
 def plot_meshes(meshes):
-    """this function plots a list of meshes on the same plot."""
+    """This function plots a list of meshes on the same plot."""
     plt.figure(figsize=(8, 4))
     for i, mesh in enumerate(meshes):
         mesh_x = mesh[:, :, 0]
diff --git a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_AS.py b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_AS.py
index 175664a05..f7cd290d0 100644
--- a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_AS.py
+++ b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_AS.py
@@ -1,5 +1,6 @@
 """Optimizes the section twist distribution of a two section symmetrical wing using the construction-based approach for section
-joining and the aerostructural tube model. This example is referenced as part of the multi-section tutorial."""
+joining and the aerostructural tube model. This example is referenced as part of the multi-section tutorial.
+"""
 
 # docs checkpoint 0
 import numpy as np
diff --git a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_construction.py b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_construction.py
index 58fe418f2..83bb1edb1 100644
--- a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_construction.py
+++ b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_construction.py
@@ -1,5 +1,6 @@
 """Optimizes the section chord distribution of a two section symmetrical wing using the construction-based approach for section
-joining. This example is referenced as part of the multi-section tutorial."""
+joining. This example is referenced as part of the multi-section tutorial.
+"""
 
 # docs checkpoint 0
 import numpy as np
@@ -230,7 +231,7 @@
 
 # Plot the results
 def plot_meshes(meshes):
-    """this function plots a list of meshes on the same plot."""
+    """This function plots a list of meshes on the same plot."""
     plt.figure(figsize=(8, 4))
     for i, mesh in enumerate(meshes):
         mesh_x = mesh[:, :, 0]
diff --git a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_visc.py b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_visc.py
index c42893b87..697c06eaa 100644
--- a/openaerostruct/docs/advanced_features/scripts/basic_2_sec_visc.py
+++ b/openaerostruct/docs/advanced_features/scripts/basic_2_sec_visc.py
@@ -1,6 +1,7 @@
 """Optimizes the section chord distribution of a two section symmetrical wing with thickenss and viscous effects accounted
 for. This examples is similar to the inviscid case but explains how to connect the unified t/c B-spline to the OAS performance
-component for correct viscous drag computation. This example is referenced as part of the multi-section tutorial."""
+component for correct viscous drag computation. This example is referenced as part of the multi-section tutorial.
+"""
 
 import numpy as np
 
@@ -169,7 +170,7 @@
 
 # Plot the results
 def plot_meshes(meshes):
-    """this function plots to plot the mesh"""
+    """This function plots to plot the mesh"""
     plt.figure(figsize=(8, 4))
     for i, mesh in enumerate(meshes):
         mesh_x = mesh[:, :, 0]
diff --git a/openaerostruct/docs/advanced_features/scripts/run_vsp_777.py b/openaerostruct/docs/advanced_features/scripts/run_vsp_777.py
index bc92533ba..ba3f93daf 100644
--- a/openaerostruct/docs/advanced_features/scripts/run_vsp_777.py
+++ b/openaerostruct/docs/advanced_features/scripts/run_vsp_777.py
@@ -4,6 +4,7 @@
 
 777 vsp model avaialable here: http://hangar.openvsp.org/vspfiles/375
 """
+
 import os
 import numpy as np
 
diff --git a/openaerostruct/docs/aerostructural_index.rst b/openaerostruct/docs/aerostructural_index.rst
index 9a3d52840..5a736f2ae 100644
--- a/openaerostruct/docs/aerostructural_index.rst
+++ b/openaerostruct/docs/aerostructural_index.rst
@@ -16,4 +16,4 @@ Then, you can review the wingbox walkthrough to understand how OAS models more d
 .. toctree::
    :maxdepth: 1
 
-   aerostructural_wingbox_walkthrough.rst
\ No newline at end of file
+   aerostructural_wingbox_walkthrough.rst
diff --git a/openaerostruct/docs/index.rst b/openaerostruct/docs/index.rst
index d67f91cf3..39364e1c5 100644
--- a/openaerostruct/docs/index.rst
+++ b/openaerostruct/docs/index.rst
@@ -63,7 +63,7 @@ How to Contribute
    :maxdepth: 1
 
    how_to_contribute.rst
-   
+
 Source Docs
 ===========
 
diff --git a/openaerostruct/docs/user_reference.rst b/openaerostruct/docs/user_reference.rst
index b03279b09..5e896f84a 100644
--- a/openaerostruct/docs/user_reference.rst
+++ b/openaerostruct/docs/user_reference.rst
@@ -9,4 +9,4 @@ User Reference
 
    user_reference/mesh_surface_dict.rst
    user_reference/debugging_tips.rst
-   user_reference/v1_v2_conversion.rst
\ No newline at end of file
+   user_reference/v1_v2_conversion.rst
diff --git a/openaerostruct/docs/user_reference/debugging_tips.rst b/openaerostruct/docs/user_reference/debugging_tips.rst
index 3226c4519..eb99982b0 100644
--- a/openaerostruct/docs/user_reference/debugging_tips.rst
+++ b/openaerostruct/docs/user_reference/debugging_tips.rst
@@ -17,4 +17,4 @@ Here are some common issues and possible solutions for them.
 
 - If you are unsure of where a parameter or unknown is within the problem, view the N2 diagram. You can generate an html file by writing `openmdao.n2(prob)` in the runscript. You can use the search function to look for specific variables.
 
-- Use the `thickness_intersects` constraint when varying thickness to maintain a physically possible solution.
\ No newline at end of file
+- Use the `thickness_intersects` constraint when varying thickness to maintain a physically possible solution.
diff --git a/openaerostruct/docs/user_reference/mesh_surface_dict.rst b/openaerostruct/docs/user_reference/mesh_surface_dict.rst
index aa1155055..f43a286d7 100644
--- a/openaerostruct/docs/user_reference/mesh_surface_dict.rst
+++ b/openaerostruct/docs/user_reference/mesh_surface_dict.rst
@@ -18,35 +18,35 @@ Here is a list of the keys and default values of the ``mesh_dict``, which is use
       - Description
     * - num_x
       - 3
-      - 
+      -
       - Number of chordwise vertices.
     * - num_y
       - 5
-      - 
+      -
       - Number of spanwise vertices for the entire wing. When ``symmetry = True``, the number of vertices for a half wing will be ``(num_y + 1) / 2``.
     * - span
       - 10.0
       - m
-      - Full wingspan, even for symmetric cases. 
+      - Full wingspan, even for symmetric cases.
     * - root_chord
       - 1.0
       - m
       - Root chord length.
     * - span_cos_spacing
       - 0
-      - 
+      -
       - Spanwise cosine spacing. 0 for uniform spanwise panels, 1 for cosine-spaced panels.
     * - chord_cos_spacing
       - 0
-      - 
+      -
       - Chordwise cosine spacing.
     * - wing_type
       - "rect"
-      - 
+      -
       - Initial shape of the wing. ``"rect"`` or ``"CRM"``.
     * - symmetry
       - True
-      - 
+      -
       - If true, OAS models half of the wing reflected across the plane ``y = 0``.
     * - offset
       - np.array([0, 0, 0])
@@ -54,9 +54,9 @@ Here is a list of the keys and default values of the ``mesh_dict``, which is use
       - Coordinates to offset the surface from its default location.
     * - num_twist_cp
       - 2
-      - 
+      -
       - Number of twist control points. Only relevant when ``wing_type = "CRM"``.
- 
+
 
 Surface Dict
 ------------
@@ -73,15 +73,15 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Description
     * - name
       - "wing"
-      - 
+      -
       - Name of the surface.
     * - symmetry
       - True or False
-      - 
+      -
       - If true, OAS models half of the wing reflected across the plane ``y = 0``.
     * - S_ref_type
       - "wetted" or "projected"
-      - 
+      -
       - How we compute the wing reference area.
     * - mesh
       - 3D ndarray or "gen-mesh"
@@ -93,7 +93,7 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Wing span.
     * - taper
       - 0.5
-      - 
+      -
       - Wing taper ratio.
     * - sweep
       - 10.0
@@ -109,7 +109,7 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - B-spline control points for twist distribution. Array convention is ``[wing tip, ..., root]`` in symmetry cases, and ``[tip, ..., root, ... tip]`` when ``symmetry = False``.
     * - chord_cp
       - np.array([0.1, 5])
-      - 
+      -
       - B-spline control points for chord distribution. This is a chord scaler applied to the initial mesh, not the chord value [m] itself. Array convention is the same as ``twist_cp``.
     * - xshear_cp
       - np.array([0.1, 0.2])
@@ -125,7 +125,7 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - B-spline control points for the z-wise shear deformation of the wing.
     * - ref_axis_pos
       - 0.25
-      - 
+      -
       - Position of reference axis along the chord about which to apply twist, chord, taper, and span geometry transformations. 1 is the trailing edge, 0 is the leading edge.
 
 .. list-table:: Multi-section Surface definition
@@ -138,19 +138,19 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Description
     * - is_multi_section
       - True
-      - 
+      -
       - This key must be present and set to True for the AeroPoint to correctly interpret this surface as multi-section.
     * - num_sections
       - 2
-      - 
+      -
       - The number of sections in the multi-section surface.
     * - sec_name
       - ["sec0","sec1","sec2"]
-      - 
+      -
       - Names of the individual sections. Each section must be named and the list length must match the specified number of sections.
     * - meshes
       - "gen-meshes" or [mesh1,mesh2,...]
-      - 
+      -
       - Supply a list of meshes for each section or "gen-meshes" for automatic mesh generation
     * - root_chord
       - 1.0
@@ -162,23 +162,23 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Wing span for each section. The list length must match the specified number of sections.
     * - ny
       - [21,21]
-      - 
+      -
       - Number of spanwise points for each section. The list length must match the specified number of sections. (required if using the built-in multi-section mesh generator)
     * - nx
       - 10
-      - 
+      -
       - Number of chordwise points. Same for all sections.(required if using the built-in multi-section mesh generator)
     * - bpanels
       - [10,10]
-      - 
+      -
       - Number of spanwise panels for each section. The list length must match the specified number of sections. An alternative to specifying nx.
     * - cpanels
       - [10,10]
-      - 
+      -
       - Number of chordwise panels for each section. An alternative to specifying ny.
     * - root_section
       - 1
-      - 
+      -
       - Root chord length of the section indicated as "root section"(required if using the built-in mesh generator)
 
 .. list-table:: Aerodynamics definitions
@@ -191,35 +191,35 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Description
     * - CL0
       - 0.0
-      - 
+      -
       - Lift coefficient of the surface at 0 angle of attack.
     * - CD0
       - 0.015
-      - 
+      -
       - Drag coefficient of the surface at 0 angle of attack.
     * - with_viscous
       - True or False
-      - 
+      -
       - If true, compute viscous drag
     * - with_wave
       - True or False
-      - 
+      -
       - If true, compute wage drag
     * - groundplane
       - True or False
-      - 
+      -
       - If true, compute ground effect.
     * - k_lam
       - 0.05
-      - 
+      -
       - Airfoil property for viscous drag calculation. Percentage of chord with lanimar flow.
     * - t_over_c_cp
       - np.array([0.12, 0.12])
-      - 
+      -
       - B-spline control points for airfoil thickness-over-chord ratio
     * - c_max_t
       - 0.303
-      - 
+      -
       - Chordwise nondimensional location of the maximum airfoil thickness.
 
 .. list-table:: Structure definitions
@@ -232,7 +232,7 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Description
     * - fem_model_type
       - "tube" or "wingbox"
-      - 
+      -
       - Structure model.
     * - E
       - 73.1e9
@@ -252,23 +252,23 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Material density
     * - fem_origin
       - 0.35
-      - 
+      -
       - Normalized chordwise location of the spar
     * - wing_weight_ratio
       - 2.0
-      - 
+      -
       - Ratio of the total wing weight (including non-structural components) to the wing structural weight.
     * - exact_failure_constraint
       - True or False
-      - 
+      -
       - If False, we use KS function to aggregate the stress constraint.
     * - struct_weight_relief
       - True or False
-      - 
+      -
       - Set True to add the weight of the structure to the loads on the structure.
     * - distributed_fuel_weight
       - True or False
-      - 
+      -
       - Set True to distribute the fuel weight across the entire wing.
     * - fuel_density
       - 803.0
@@ -280,7 +280,7 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Reserve fuel mass
     * - n_point_masses
       - 1
-      - 
+      -
       - Number of point masses in the system (for example, engine)
 
 
@@ -319,27 +319,27 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Control point of skin thickness distribution.
     * - original_wingbox _airfoil_t_over_c
       - 0.12
-      - 
+      -
       - Thickness-over-chord ratio of airfoil provided for the wingbox cross-section.
     * - strength_factor _for_upper_skin
       - 1.0
-      - 
+      -
       - A factor to adjust the yield strength of the upper skin relative to the lower skin.
     * - data_x_upper
       - 1D ndarray
-      - 
+      -
       - ``x`` coordinates of the wingbox cross-section's upper surface for an airfoil with the chord scaled to 1.
     * - data_y_upper
       - 1D ndarray
-      - 
+      -
       - ``y`` coordinates of the wingbox cross-section's upper surface
     * - data_x_lower
       - 1D ndarray
-      - 
+      -
       - ``x`` coordinates of the wingbox cross-section's lower surface
     * - data_y_lower
       - 1D ndarray
-      - 
+      -
       - ``y`` coordinates of the wingbox cross-section's lower surface
 
 .. list-table:: FFD parameters
@@ -352,11 +352,11 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Description
     * - mx
       - 2
-      - 
+      -
       - Number of the FFD control points in the x direction.
     * - my
       - 2
-      - 
+      -
       - Number of the FFD control points in the y direction.
 ..
-  TODO: list default values (if any), and whethre each key is required or optional.
\ No newline at end of file
+  TODO: list default values (if any), and whethre each key is required or optional.
diff --git a/openaerostruct/docs/user_reference/v1_v2_conversion.rst b/openaerostruct/docs/user_reference/v1_v2_conversion.rst
index a90f23ac8..03ab69f96 100644
--- a/openaerostruct/docs/user_reference/v1_v2_conversion.rst
+++ b/openaerostruct/docs/user_reference/v1_v2_conversion.rst
@@ -146,4 +146,4 @@ v2 Script
 .. literalinclude:: /../../tests/integration_tests/test_v1_aero_opt.py
   :start-after: checkpoint 0
   :end-before: checkpoint 5
-  :dedent: 8
\ No newline at end of file
+  :dedent: 8
diff --git a/openaerostruct/geometry/ffd_component.py b/openaerostruct/geometry/ffd_component.py
index 008821ad4..853da75a9 100644
--- a/openaerostruct/geometry/ffd_component.py
+++ b/openaerostruct/geometry/ffd_component.py
@@ -21,8 +21,7 @@ class GeometryMesh(om.ExplicitComponent):
     If parameters are not active (they do not deform the mesh), then
     they will not be given to this component.
 
-    Parameters
-    ----------
+
 
     Returns
     -------
diff --git a/openaerostruct/geometry/geometry_mesh.py b/openaerostruct/geometry/geometry_mesh.py
index f8ed23ddb..1b7512332 100644
--- a/openaerostruct/geometry/geometry_mesh.py
+++ b/openaerostruct/geometry/geometry_mesh.py
@@ -1,4 +1,4 @@
-""" Group that manipulates geometry mesh based on high-level design parameters. """
+"""Group that manipulates geometry mesh based on high-level design parameters."""
 
 import numpy as np
 
diff --git a/openaerostruct/geometry/geometry_mesh_transformations.py b/openaerostruct/geometry/geometry_mesh_transformations.py
index 9c639869b..9c47273c0 100644
--- a/openaerostruct/geometry/geometry_mesh_transformations.py
+++ b/openaerostruct/geometry/geometry_mesh_transformations.py
@@ -1,5 +1,6 @@
 """A set of components that manipulate geometry mesh
-based on high-level design parameters."""
+based on high-level design parameters.
+"""
 
 import numpy as np
 
diff --git a/openaerostruct/geometry/radius_comp.py b/openaerostruct/geometry/radius_comp.py
index f58a1d54e..a3fe53ce2 100644
--- a/openaerostruct/geometry/radius_comp.py
+++ b/openaerostruct/geometry/radius_comp.py
@@ -1,4 +1,4 @@
-""" Manipulate geometry mesh based on high-level design parameters. """
+"""Manipulate geometry mesh based on high-level design parameters."""
 
 import numpy as np
 
diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 884d04478..0237a248c 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -341,7 +341,7 @@ def initialize(self):
             "compressible",
             types=bool,
             default=False,
-            desc="Turns on compressibility correction for moderate Mach number " "flows. Defaults to False.",
+            desc="Turns on compressibility correction for moderate Mach number flows. Defaults to False.",
         )
         self.options.declare(
             "rotational", False, types=bool, desc="Set to True to turn on support for computing angular velocities"
diff --git a/openaerostruct/meshing/section_mesh_generator.py b/openaerostruct/meshing/section_mesh_generator.py
index 7f6d0c22d..10367a755 100644
--- a/openaerostruct/meshing/section_mesh_generator.py
+++ b/openaerostruct/meshing/section_mesh_generator.py
@@ -396,7 +396,7 @@ def output_oas_mesh(panel_geom_x, panel_geom_y):
     meshT, sec_meshes = generate_mesh(surface)
 
     def plot_meshes(meshes):
-        """this function plots to plot the mesh"""
+        """This function plots to plot the mesh"""
         plt.figure(figsize=(8, 4))
         for i, mesh in enumerate(meshes):
             mesh_x = mesh[:, :, 0]
diff --git a/openaerostruct/mphys/mux_surface_forces.py b/openaerostruct/mphys/mux_surface_forces.py
index c9689570e..c07792333 100644
--- a/openaerostruct/mphys/mux_surface_forces.py
+++ b/openaerostruct/mphys/mux_surface_forces.py
@@ -41,7 +41,7 @@ def setup(self):
                 distributed=False,
                 shape=mesh.shape,
                 units="N",
-                desc="Array defining the aero forces " "on mesh nodes of the lifting surface.",
+                desc="Array defining the aero forces on mesh nodes of the lifting surface.",
                 tags=["mphys_coupling"],
             )
 
diff --git a/openaerostruct/structures/failure_ks.py b/openaerostruct/structures/failure_ks.py
index db7941b95..b7cbb9f7d 100644
--- a/openaerostruct/structures/failure_ks.py
+++ b/openaerostruct/structures/failure_ks.py
@@ -19,7 +19,7 @@ class FailureKS(om.ExplicitComponent):
     the failure constraints. A lower value is more conservative while a greater
     value is more aggressive (closer approximation to the max() function).
 
-    parameters
+    Parameters
     ----------
     vonmises[ny-1, 2] : numpy array
         von Mises stress magnitudes for each FEM element.
diff --git a/openaerostruct/structures/fuel_loads.py b/openaerostruct/structures/fuel_loads.py
index b8eb0d183..dbf64b958 100644
--- a/openaerostruct/structures/fuel_loads.py
+++ b/openaerostruct/structures/fuel_loads.py
@@ -13,11 +13,7 @@ class FuelLoads(om.ExplicitComponent):
     Compute the nodal loads from the distributed fuel within the wing
     to be applied to the wing structure.
 
-    Parameters
-    ----------
 
-    Returns
-    -------
 
     """
 
diff --git a/openaerostruct/structures/fuel_vol.py b/openaerostruct/structures/fuel_vol.py
index 510b8e884..e0f8d699f 100644
--- a/openaerostruct/structures/fuel_vol.py
+++ b/openaerostruct/structures/fuel_vol.py
@@ -11,7 +11,7 @@ class WingboxFuelVol(om.ExplicitComponent):
     """
     Computes the internal volumes of the wingbox segments.
 
-    parameters
+    Parameters
     ----------
     nodes[ny, 3] : numpy array
         Coordinates of FEM nodes.
diff --git a/openaerostruct/structures/non_intersecting_thickness.py b/openaerostruct/structures/non_intersecting_thickness.py
index 61ddf0deb..0aead07a8 100644
--- a/openaerostruct/structures/non_intersecting_thickness.py
+++ b/openaerostruct/structures/non_intersecting_thickness.py
@@ -9,7 +9,7 @@ class NonIntersectingThickness(om.ExplicitComponent):
     itself in the center of the spar. Basically, the thickness must be less
     than or equal to the radius.
 
-    parameters
+    Parameters
     ----------
     thickness[ny-1] : numpy array
         Thickness of each element of the FEM spar.
diff --git a/openaerostruct/structures/section_properties_tube.py b/openaerostruct/structures/section_properties_tube.py
index d14dc83ec..94e27a822 100644
--- a/openaerostruct/structures/section_properties_tube.py
+++ b/openaerostruct/structures/section_properties_tube.py
@@ -9,7 +9,7 @@ class SectionPropertiesTube(om.ExplicitComponent):
     The thicknesses are added to the interior of the element, so the
     'radius' value is the outer radius of the tube.
 
-    parameters
+    Parameters
     ----------
     radius : numpy array
         Outer radii for each FEM element.
diff --git a/openaerostruct/structures/section_properties_wingbox.py b/openaerostruct/structures/section_properties_wingbox.py
index b09ff8a0f..f7e6d9ba8 100644
--- a/openaerostruct/structures/section_properties_wingbox.py
+++ b/openaerostruct/structures/section_properties_wingbox.py
@@ -227,12 +227,10 @@ def compute(self, inputs, outputs):
         x2 = x_up_diff
 
         I_horiz_1 = 2 * (
-            (
-                1.0 / 12.0 * a**3 * x2**4
-                + 1.0 / 3.0 * a**2 * x2**3 * b
-                + 1.0 / 2.0 * a * x2**2 * b**2
-                + 1.0 / 3.0 * b**3 * x2
-            )
+            1.0 / 12.0 * a**3 * x2**4
+            + 1.0 / 3.0 * a**2 * x2**3 * b
+            + 1.0 / 2.0 * a * x2**2 * b**2
+            + 1.0 / 3.0 * b**3 * x2
         )
         I_horiz_2 = x2 * skin_thickness * (y_up_add / 2 - skin_thickness / 2 - centroid) ** 2
 
@@ -246,12 +244,10 @@ def compute(self, inputs, outputs):
         I_horiz += np.sum(
             2
             * (
-                (
-                    1.0 / 12.0 * a**3 * x2**4
-                    + 1.0 / 3.0 * a**2 * x2**3 * b
-                    + 1.0 / 2.0 * a * x2**2 * b**2
-                    + 1.0 / 3.0 * b**3 * x2
-                )
+                1.0 / 12.0 * a**3 * x2**4
+                + 1.0 / 3.0 * a**2 * x2**3 * b
+                + 1.0 / 2.0 * a * x2**2 * b**2
+                + 1.0 / 3.0 * b**3 * x2
             ),
             axis=0,
         )
diff --git a/openaerostruct/structures/spar_within_wing.py b/openaerostruct/structures/spar_within_wing.py
index a3042c0f6..971d8aafa 100644
--- a/openaerostruct/structures/spar_within_wing.py
+++ b/openaerostruct/structures/spar_within_wing.py
@@ -13,7 +13,7 @@ class SparWithinWing(om.ExplicitComponent):
         This component has not been extensively tested.
         It may require additional coding to work as intended.
 
-    parameters
+    Parameters
     ----------
     mesh[nx, ny, 3] : numpy array
         Array defining the nodal points of the lifting surface.
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index cff8cdd76..5cd4e8d85 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -12,7 +12,8 @@
 
 class SpatialBeamFunctionals(om.Group):
     """Group that contains the spatial beam functionals used to evaluate
-    performance."""
+    performance.
+    """
 
     def initialize(self):
         self.options.declare("surface", types=dict)
diff --git a/openaerostruct/structures/spatial_beam_setup.py b/openaerostruct/structures/spatial_beam_setup.py
index 7c4b490d8..fedcfa0b7 100644
--- a/openaerostruct/structures/spatial_beam_setup.py
+++ b/openaerostruct/structures/spatial_beam_setup.py
@@ -8,7 +8,8 @@
 
 class SpatialBeamSetup(om.Group):
     """Group that sets up the spatial beam components and assembles the
-    stiffness matrix."""
+    stiffness matrix.
+    """
 
     def initialize(self):
         self.options.declare("surface", types=dict)
diff --git a/openaerostruct/structures/structural_cg.py b/openaerostruct/structures/structural_cg.py
index 23d3170fc..fa0a202cd 100644
--- a/openaerostruct/structures/structural_cg.py
+++ b/openaerostruct/structures/structural_cg.py
@@ -6,7 +6,7 @@
 class StructuralCG(om.ExplicitComponent):
     """Compute center-of-gravity location of the spar elements.
 
-    parameters
+    Parameters
     ----------
     A[ny-1] : numpy array
         Areas for each FEM element.
diff --git a/openaerostruct/structures/vonmises_tube.py b/openaerostruct/structures/vonmises_tube.py
index cfe243e56..9f44474f9 100644
--- a/openaerostruct/structures/vonmises_tube.py
+++ b/openaerostruct/structures/vonmises_tube.py
@@ -8,7 +8,7 @@
 class VonMisesTube(om.ExplicitComponent):
     """Compute the von Mises stress in each element.
 
-    parameters
+    Parameters
     ----------
     nodes[ny, 3] : numpy array
         Flattened array with coordinates for each FEM node.
diff --git a/openaerostruct/structures/weight.py b/openaerostruct/structures/weight.py
index cac26942f..11913dc5f 100644
--- a/openaerostruct/structures/weight.py
+++ b/openaerostruct/structures/weight.py
@@ -7,7 +7,7 @@
 class Weight(om.ExplicitComponent):
     """Compute total weight and center-of-gravity location of the spar elements.
 
-    parameters
+    Parameters
     ----------
     A[ny-1] : numpy array
         Areas for each FEM element.
diff --git a/openaerostruct/structures/wing_weight_loads.py b/openaerostruct/structures/wing_weight_loads.py
index 61ced5b2a..6056535d2 100644
--- a/openaerostruct/structures/wing_weight_loads.py
+++ b/openaerostruct/structures/wing_weight_loads.py
@@ -112,7 +112,7 @@ def setup(self):
         nym1_rand = rng.random(nym1)
 
         dzm_dnodes_pattern = (
-            (diags(nym1_rand * nym1_rand) * self.ddel0__dnodes + diags(nym1_rand * nym1_rand) * self.ddel1__dnodes)
+            diags(nym1_rand * nym1_rand) * self.ddel0__dnodes + diags(nym1_rand * nym1_rand) * self.ddel1__dnodes
         ).tocsr()
 
         dbm3_dnodes = (
diff --git a/openaerostruct/utils/testing.py b/openaerostruct/utils/testing.py
index 444852da8..6f2308d62 100644
--- a/openaerostruct/utils/testing.py
+++ b/openaerostruct/utils/testing.py
@@ -348,7 +348,8 @@ def get_two_section_surface(sym=True, visc=False):
 
 def get_single_section_surface():
     """Create a dictionary with info and options about the aerodynamic
-    single section lifting surface"""
+    single section lifting surface
+    """
 
     # Create a dictionary to store options about the mesh
     mesh_dict = {
@@ -457,7 +458,8 @@ def get_two_section_surface_AS(sym=True):
 
 def get_single_section_surface_AS():
     """Create a dictionary with info and options about the aerodynamic
-    single section lifting surface"""
+    single section lifting surface
+    """
 
     # Create a dictionary to store options about the mesh
     mesh_dict = {
diff --git a/ruff.toml b/ruff.toml
new file mode 100644
index 000000000..8f02b77ab
--- /dev/null
+++ b/ruff.toml
@@ -0,0 +1,10 @@
+extend = "~/.config/ruff/ruff.toml"
+
+# OpenAeroStruct-specific settings in addition to the MDO Lab standard config file.
+extend-exclude = [
+    "openaerostruct/docs/conf.py",
+    "openaerostruct/docs/aero_walkthrough/part*.py",
+    "openaerostruct/docs/_utils/docutil.py",
+    "openaerostruct/docs/_utils/patch.py",
+    "openaerostruct/utils/plot_*.py",
+]
diff --git a/setup.py b/setup.py
index cb2b35cba..099b3535e 100644
--- a/setup.py
+++ b/setup.py
@@ -68,4 +68,3 @@
     plot_wingbox=openaerostruct.utils.plot_wingbox:disp_plot
     """,
 )
-
diff --git a/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py b/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
index e8c6f9bff..38427937c 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
@@ -272,7 +272,6 @@ def test(self):
             "data_x_lower": lower_x,
             "data_y_upper": upper_y,
             "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
             # Aerodynamic performance of the lifting surface at
             # an angle of attack of 0 (alpha=0).
             # These CL0 and CD0 values are added to the CL and CD
diff --git a/tests/integration_tests/test_aerostruct_wingbox_analysis.py b/tests/integration_tests/test_aerostruct_wingbox_analysis.py
index c6239dca5..f098605b6 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_analysis.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_analysis.py
@@ -272,7 +272,6 @@ def test(self):
             "data_x_lower": lower_x,
             "data_y_upper": upper_y,
             "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
             # Aerodynamic performance of the lifting surface at
             # an angle of attack of 0 (alpha=0).
             # These CL0 and CD0 values are added to the CL and CD
diff --git a/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py b/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
index 5c76f53f8..4a15737e3 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
@@ -1,444 +1,443 @@
-from openmdao.utils.assert_utils import assert_near_equal
-import unittest
-import numpy as np
-
-from openaerostruct.meshing.mesh_generator import generate_mesh
-from openaerostruct.utils.testing import assert_opt_successful
-
-from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
-
-import openmdao.api as om
-from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
-
-# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
-# These should be for an airfoil with the chord scaled to 1.
-# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
-# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
-# The first and last x-coordinates of the upper and lower skins must be the same
-
-upper_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-lower_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-upper_y = np.array(
-    [
-        0.0447,
-        0.046,
-        0.0472,
-        0.0484,
-        0.0495,
-        0.0505,
-        0.0514,
-        0.0523,
-        0.0531,
-        0.0538,
-        0.0545,
-        0.0551,
-        0.0557,
-        0.0563,
-        0.0568,
-        0.0573,
-        0.0577,
-        0.0581,
-        0.0585,
-        0.0588,
-        0.0591,
-        0.0593,
-        0.0595,
-        0.0597,
-        0.0599,
-        0.06,
-        0.0601,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0601,
-        0.06,
-        0.0599,
-        0.0598,
-        0.0596,
-        0.0594,
-        0.0592,
-        0.0589,
-        0.0586,
-        0.0583,
-        0.058,
-        0.0576,
-        0.0572,
-        0.0568,
-        0.0563,
-        0.0558,
-        0.0553,
-        0.0547,
-        0.0541,
-    ],
-    dtype="complex128",
-)
-lower_y = np.array(
-    [
-        -0.0447,
-        -0.046,
-        -0.0473,
-        -0.0485,
-        -0.0496,
-        -0.0506,
-        -0.0515,
-        -0.0524,
-        -0.0532,
-        -0.054,
-        -0.0547,
-        -0.0554,
-        -0.056,
-        -0.0565,
-        -0.057,
-        -0.0575,
-        -0.0579,
-        -0.0583,
-        -0.0586,
-        -0.0589,
-        -0.0592,
-        -0.0594,
-        -0.0595,
-        -0.0596,
-        -0.0597,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0597,
-        -0.0596,
-        -0.0594,
-        -0.0592,
-        -0.0589,
-        -0.0586,
-        -0.0582,
-        -0.0578,
-        -0.0573,
-        -0.0567,
-        -0.0561,
-        -0.0554,
-        -0.0546,
-        -0.0538,
-        -0.0529,
-        -0.0519,
-        -0.0509,
-        -0.0497,
-        -0.0485,
-        -0.0472,
-        -0.0458,
-        -0.0444,
-    ],
-    dtype="complex128",
-)
-
-
-class Test(unittest.TestCase):
-    def test(self):
-        """
-        This is an opt problem that tests the fuel volume constraint with the wingbox model
-        """
-
-        # Create a dictionary to store options about the surface
-        mesh_dict = {
-            "num_y": 7,
-            "num_x": 2,
-            "wing_type": "CRM",
-            "symmetry": True,
-            "num_twist_cp": 6,
-            "chord_cos_spacing": 0,
-            "span_cos_spacing": 0,
-        }
-
-        mesh, twist_cp = generate_mesh(mesh_dict)
-
-        surf_dict = {
-            # Wing definition
-            "name": "wing",  # name of the surface
-            "symmetry": True,  # if true, model one half of wing
-            # reflected across the plane y = 0
-            "S_ref_type": "wetted",  # how we compute the wing area,
-            # can be 'wetted' or 'projected'
-            "fem_model_type": "wingbox",
-            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
-            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
-            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
-            "mesh": mesh,
-            "data_x_upper": upper_x,
-            "data_x_lower": lower_x,
-            "data_y_upper": upper_y,
-            "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
-            # Aerodynamic performance of the lifting surface at
-            # an angle of attack of 0 (alpha=0).
-            # These CL0 and CD0 values are added to the CL and CD
-            # obtained from aerodynamic analysis of the surface to get
-            # the total CL and CD.
-            # These CL0 and CD0 values do not vary wrt alpha.
-            "CL0": 0.0,  # CL of the surface at alpha=0
-            "CD0": 0.0078,  # CD of the surface at alpha=0
-            # Airfoil properties for viscous drag calculation
-            "k_lam": 0.05,  # percentage of chord with laminar
-            # flow, used for viscous drag
-            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
-            "original_wingbox_airfoil_t_over_c": 0.12,
-            "c_max_t": 0.38,  # chordwise location of maximum thickness
-            "with_viscous": True,
-            "with_wave": False,  # if true, compute wave drag
-            # Structural values are based on aluminum 7075
-            "E": 73.1e9,  # [Pa] Young's modulus
-            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
-            "mrho": 2.78e3,  # [kg/m^3] material density
-            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
-            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
-            "wing_weight_ratio": 1.25,
-            "struct_weight_relief": True,
-            "distributed_fuel_weight": False,
-            # Constraints
-            "exact_failure_constraint": False,  # if false, use KS function
-            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
-            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
-        }
-
-        surfaces = [surf_dict]
-
-        # Create the problem and assign the model group
-        prob = om.Problem()
-
-        # Add problem information as an independent variables component
-        indep_var_comp = om.IndepVarComp()
-        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
-        indep_var_comp.add_output("alpha", val=0.0, units="deg")
-        indep_var_comp.add_output("Mach_number", val=0.85)
-        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
-        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
-        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
-        indep_var_comp.add_output("R", val=14.307e6, units="m")
-        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
-        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
-        indep_var_comp.add_output("load_factor", val=1.0)
-        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
-
-        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
-
-        # Loop over each surface in the surfaces list
-        for surface in surfaces:
-            # Get the surface name and create a group to contain components
-            # only for this surface
-            name = surface["name"]
-
-            aerostruct_group = AerostructGeometry(surface=surface)
-
-            # Add tmp_group to the problem with the name of the surface.
-            prob.model.add_subsystem(name, aerostruct_group)
-
-        # Loop through and add a certain number of aero points
-        for i in range(1):
-            point_name = "AS_point_{}".format(i)
-            # Connect the parameters within the model for each aero point
-
-            # Create the aero point group and add it to the model
-            AS_point = AerostructPoint(surfaces=surfaces)
-
-            prob.model.add_subsystem(point_name, AS_point)
-
-            # Connect flow properties to the analysis point
-            prob.model.connect("v", point_name + ".v")
-            prob.model.connect("alpha", point_name + ".alpha")
-            prob.model.connect("Mach_number", point_name + ".Mach_number")
-            prob.model.connect("re", point_name + ".re")
-            prob.model.connect("rho", point_name + ".rho")
-            prob.model.connect("CT", point_name + ".CT")
-            prob.model.connect("R", point_name + ".R")
-            prob.model.connect("W0", point_name + ".W0")
-            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
-            prob.model.connect("empty_cg", point_name + ".empty_cg")
-            prob.model.connect("load_factor", point_name + ".load_factor")
-
-            for _surface in surfaces:
-                com_name = point_name + "." + name + "_perf."
-                prob.model.connect(
-                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
-                )
-                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
-
-                # Connect aerodyamic mesh to coupled group mesh
-                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
-                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
-
-                # Connect performance calculation variables
-                prob.model.connect(name + ".nodes", com_name + "nodes")
-                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
-                prob.model.connect(
-                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
-                )
-
-                # Connect wingbox properties to von Mises stress calcs
-                prob.model.connect(name + ".Qz", com_name + "Qz")
-                prob.model.connect(name + ".J", com_name + "J")
-                prob.model.connect(name + ".A_enc", com_name + "A_enc")
-                prob.model.connect(name + ".htop", com_name + "htop")
-                prob.model.connect(name + ".hbottom", com_name + "hbottom")
-                prob.model.connect(name + ".hfront", com_name + "hfront")
-                prob.model.connect(name + ".hrear", com_name + "hrear")
-
-                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
-                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
-
-            # =======================================================================================
-            # Here we add the fuel volume constraint componenet to the model
-            # =======================================================================================
-            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
-            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
-            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
-            # =======================================================================================
-            # =======================================================================================
-
-        prob.driver = om.ScipyOptimizeDriver()
-        prob.driver.options["tol"] = 1e-9
-
-        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
-
-        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
-        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
-
-        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
-        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
-
-        # =======================================================================================
-        # Here we add the fuel volume constraint
-        # =======================================================================================
-        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
-        # =======================================================================================
-        # =======================================================================================
-
-        # Set up the problem
-        prob.setup()
-
-        optResult = prob.run_driver()
-
-        print(prob["AS_point_0.fuelburn"][0])
-        print(prob["wing.structural_mass"][0] / 1.25)
-        print(prob["fuel_vol_delta.fuel_vol_delta"][0])
-
-        assert_opt_successful(self, optResult)
-        assert_near_equal(prob["AS_point_0.fuelburn"][0], 76869.3858256513, 1e-4)
-        assert_near_equal(prob["wing.structural_mass"][0], 14520.819967195273, 1e-4)
-        assert_near_equal(prob["fuel_vol_delta.fuel_vol_delta"][0], 43.02081603846062, 1e-4)
-        assert_near_equal(prob["AS_point_0.CL"][0], 0.5, 1e-5)
-
-
-if __name__ == "__main__":
-    unittest.main()
+from openmdao.utils.assert_utils import assert_near_equal
+import unittest
+import numpy as np
+
+from openaerostruct.meshing.mesh_generator import generate_mesh
+from openaerostruct.utils.testing import assert_opt_successful
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+import openmdao.api as om
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+upper_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+lower_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+upper_y = np.array(
+    [
+        0.0447,
+        0.046,
+        0.0472,
+        0.0484,
+        0.0495,
+        0.0505,
+        0.0514,
+        0.0523,
+        0.0531,
+        0.0538,
+        0.0545,
+        0.0551,
+        0.0557,
+        0.0563,
+        0.0568,
+        0.0573,
+        0.0577,
+        0.0581,
+        0.0585,
+        0.0588,
+        0.0591,
+        0.0593,
+        0.0595,
+        0.0597,
+        0.0599,
+        0.06,
+        0.0601,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0601,
+        0.06,
+        0.0599,
+        0.0598,
+        0.0596,
+        0.0594,
+        0.0592,
+        0.0589,
+        0.0586,
+        0.0583,
+        0.058,
+        0.0576,
+        0.0572,
+        0.0568,
+        0.0563,
+        0.0558,
+        0.0553,
+        0.0547,
+        0.0541,
+    ],
+    dtype="complex128",
+)
+lower_y = np.array(
+    [
+        -0.0447,
+        -0.046,
+        -0.0473,
+        -0.0485,
+        -0.0496,
+        -0.0506,
+        -0.0515,
+        -0.0524,
+        -0.0532,
+        -0.054,
+        -0.0547,
+        -0.0554,
+        -0.056,
+        -0.0565,
+        -0.057,
+        -0.0575,
+        -0.0579,
+        -0.0583,
+        -0.0586,
+        -0.0589,
+        -0.0592,
+        -0.0594,
+        -0.0595,
+        -0.0596,
+        -0.0597,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0597,
+        -0.0596,
+        -0.0594,
+        -0.0592,
+        -0.0589,
+        -0.0586,
+        -0.0582,
+        -0.0578,
+        -0.0573,
+        -0.0567,
+        -0.0561,
+        -0.0554,
+        -0.0546,
+        -0.0538,
+        -0.0529,
+        -0.0519,
+        -0.0509,
+        -0.0497,
+        -0.0485,
+        -0.0472,
+        -0.0458,
+        -0.0444,
+    ],
+    dtype="complex128",
+)
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        """
+        This is an opt problem that tests the fuel volume constraint with the wingbox model
+        """
+
+        # Create a dictionary to store options about the surface
+        mesh_dict = {
+            "num_y": 7,
+            "num_x": 2,
+            "wing_type": "CRM",
+            "symmetry": True,
+            "num_twist_cp": 6,
+            "chord_cos_spacing": 0,
+            "span_cos_spacing": 0,
+        }
+
+        mesh, twist_cp = generate_mesh(mesh_dict)
+
+        surf_dict = {
+            # Wing definition
+            "name": "wing",  # name of the surface
+            "symmetry": True,  # if true, model one half of wing
+            # reflected across the plane y = 0
+            "S_ref_type": "wetted",  # how we compute the wing area,
+            # can be 'wetted' or 'projected'
+            "fem_model_type": "wingbox",
+            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+            "mesh": mesh,
+            "data_x_upper": upper_x,
+            "data_x_lower": lower_x,
+            "data_y_upper": upper_y,
+            "data_y_lower": lower_y,
+            # Aerodynamic performance of the lifting surface at
+            # an angle of attack of 0 (alpha=0).
+            # These CL0 and CD0 values are added to the CL and CD
+            # obtained from aerodynamic analysis of the surface to get
+            # the total CL and CD.
+            # These CL0 and CD0 values do not vary wrt alpha.
+            "CL0": 0.0,  # CL of the surface at alpha=0
+            "CD0": 0.0078,  # CD of the surface at alpha=0
+            # Airfoil properties for viscous drag calculation
+            "k_lam": 0.05,  # percentage of chord with laminar
+            # flow, used for viscous drag
+            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+            "original_wingbox_airfoil_t_over_c": 0.12,
+            "c_max_t": 0.38,  # chordwise location of maximum thickness
+            "with_viscous": True,
+            "with_wave": False,  # if true, compute wave drag
+            # Structural values are based on aluminum 7075
+            "E": 73.1e9,  # [Pa] Young's modulus
+            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
+            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "mrho": 2.78e3,  # [kg/m^3] material density
+            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
+            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
+            "wing_weight_ratio": 1.25,
+            "struct_weight_relief": True,
+            "distributed_fuel_weight": False,
+            # Constraints
+            "exact_failure_constraint": False,  # if false, use KS function
+            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+        }
+
+        surfaces = [surf_dict]
+
+        # Create the problem and assign the model group
+        prob = om.Problem()
+
+        # Add problem information as an independent variables component
+        indep_var_comp = om.IndepVarComp()
+        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
+        indep_var_comp.add_output("alpha", val=0.0, units="deg")
+        indep_var_comp.add_output("Mach_number", val=0.85)
+        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
+        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+        indep_var_comp.add_output("R", val=14.307e6, units="m")
+        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+        indep_var_comp.add_output("load_factor", val=1.0)
+        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+
+        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+        # Loop over each surface in the surfaces list
+        for surface in surfaces:
+            # Get the surface name and create a group to contain components
+            # only for this surface
+            name = surface["name"]
+
+            aerostruct_group = AerostructGeometry(surface=surface)
+
+            # Add tmp_group to the problem with the name of the surface.
+            prob.model.add_subsystem(name, aerostruct_group)
+
+        # Loop through and add a certain number of aero points
+        for i in range(1):
+            point_name = "AS_point_{}".format(i)
+            # Connect the parameters within the model for each aero point
+
+            # Create the aero point group and add it to the model
+            AS_point = AerostructPoint(surfaces=surfaces)
+
+            prob.model.add_subsystem(point_name, AS_point)
+
+            # Connect flow properties to the analysis point
+            prob.model.connect("v", point_name + ".v")
+            prob.model.connect("alpha", point_name + ".alpha")
+            prob.model.connect("Mach_number", point_name + ".Mach_number")
+            prob.model.connect("re", point_name + ".re")
+            prob.model.connect("rho", point_name + ".rho")
+            prob.model.connect("CT", point_name + ".CT")
+            prob.model.connect("R", point_name + ".R")
+            prob.model.connect("W0", point_name + ".W0")
+            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+            prob.model.connect("empty_cg", point_name + ".empty_cg")
+            prob.model.connect("load_factor", point_name + ".load_factor")
+
+            for _surface in surfaces:
+                com_name = point_name + "." + name + "_perf."
+                prob.model.connect(
+                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+                )
+                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+                # Connect aerodyamic mesh to coupled group mesh
+                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+                # Connect performance calculation variables
+                prob.model.connect(name + ".nodes", com_name + "nodes")
+                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+                prob.model.connect(
+                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
+                )
+
+                # Connect wingbox properties to von Mises stress calcs
+                prob.model.connect(name + ".Qz", com_name + "Qz")
+                prob.model.connect(name + ".J", com_name + "J")
+                prob.model.connect(name + ".A_enc", com_name + "A_enc")
+                prob.model.connect(name + ".htop", com_name + "htop")
+                prob.model.connect(name + ".hbottom", com_name + "hbottom")
+                prob.model.connect(name + ".hfront", com_name + "hfront")
+                prob.model.connect(name + ".hrear", com_name + "hrear")
+
+                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+            # =======================================================================================
+            # Here we add the fuel volume constraint componenet to the model
+            # =======================================================================================
+            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+            # =======================================================================================
+            # =======================================================================================
+
+        prob.driver = om.ScipyOptimizeDriver()
+        prob.driver.options["tol"] = 1e-9
+
+        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+
+        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+        # =======================================================================================
+        # Here we add the fuel volume constraint
+        # =======================================================================================
+        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+        # =======================================================================================
+        # =======================================================================================
+
+        # Set up the problem
+        prob.setup()
+
+        optResult = prob.run_driver()
+
+        print(prob["AS_point_0.fuelburn"][0])
+        print(prob["wing.structural_mass"][0] / 1.25)
+        print(prob["fuel_vol_delta.fuel_vol_delta"][0])
+
+        assert_opt_successful(self, optResult)
+        assert_near_equal(prob["AS_point_0.fuelburn"][0], 76869.3858256513, 1e-4)
+        assert_near_equal(prob["wing.structural_mass"][0], 14520.819967195273, 1e-4)
+        assert_near_equal(prob["fuel_vol_delta.fuel_vol_delta"][0], 43.02081603846062, 1e-4)
+        assert_near_equal(prob["AS_point_0.CL"][0], 0.5, 1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_aerostruct_wingbox_opt.py b/tests/integration_tests/test_aerostruct_wingbox_opt.py
index 34dad6170..da3272945 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_opt.py
@@ -1,417 +1,416 @@
-from openmdao.utils.assert_utils import assert_near_equal
-import unittest
-import numpy as np
-
-from openaerostruct.meshing.mesh_generator import generate_mesh
-
-from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
-
-import openmdao.api as om
-
-
-# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
-# These should be for an airfoil with the chord scaled to 1.
-# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
-# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
-# The first and last x-coordinates of the upper and lower skins must be the same
-
-upper_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-lower_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-upper_y = np.array(
-    [
-        0.0447,
-        0.046,
-        0.0472,
-        0.0484,
-        0.0495,
-        0.0505,
-        0.0514,
-        0.0523,
-        0.0531,
-        0.0538,
-        0.0545,
-        0.0551,
-        0.0557,
-        0.0563,
-        0.0568,
-        0.0573,
-        0.0577,
-        0.0581,
-        0.0585,
-        0.0588,
-        0.0591,
-        0.0593,
-        0.0595,
-        0.0597,
-        0.0599,
-        0.06,
-        0.0601,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0601,
-        0.06,
-        0.0599,
-        0.0598,
-        0.0596,
-        0.0594,
-        0.0592,
-        0.0589,
-        0.0586,
-        0.0583,
-        0.058,
-        0.0576,
-        0.0572,
-        0.0568,
-        0.0563,
-        0.0558,
-        0.0553,
-        0.0547,
-        0.0541,
-    ],
-    dtype="complex128",
-)
-lower_y = np.array(
-    [
-        -0.0447,
-        -0.046,
-        -0.0473,
-        -0.0485,
-        -0.0496,
-        -0.0506,
-        -0.0515,
-        -0.0524,
-        -0.0532,
-        -0.054,
-        -0.0547,
-        -0.0554,
-        -0.056,
-        -0.0565,
-        -0.057,
-        -0.0575,
-        -0.0579,
-        -0.0583,
-        -0.0586,
-        -0.0589,
-        -0.0592,
-        -0.0594,
-        -0.0595,
-        -0.0596,
-        -0.0597,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0597,
-        -0.0596,
-        -0.0594,
-        -0.0592,
-        -0.0589,
-        -0.0586,
-        -0.0582,
-        -0.0578,
-        -0.0573,
-        -0.0567,
-        -0.0561,
-        -0.0554,
-        -0.0546,
-        -0.0538,
-        -0.0529,
-        -0.0519,
-        -0.0509,
-        -0.0497,
-        -0.0485,
-        -0.0472,
-        -0.0458,
-        -0.0444,
-    ],
-    dtype="complex128",
-)
-
-
-class Test(unittest.TestCase):
-    def test(self):
-        # Create a dictionary to store options about the surface
-        mesh_dict = {
-            "num_y": 5,
-            "num_x": 3,
-            "wing_type": "CRM",
-            "symmetry": True,
-            "num_twist_cp": 6,
-            "chord_cos_spacing": 0,
-            "span_cos_spacing": 0,
-        }
-
-        mesh, twist_cp = generate_mesh(mesh_dict)
-
-        surf_dict = {
-            # Wing definition
-            "name": "wing",  # name of the surface
-            "symmetry": True,  # if true, model one half of wing
-            # reflected across the plane y = 0
-            "S_ref_type": "wetted",  # how we compute the wing area,
-            # can be 'wetted' or 'projected'
-            "fem_model_type": "wingbox",
-            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
-            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
-            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
-            "mesh": mesh,
-            "data_x_upper": upper_x,
-            "data_x_lower": lower_x,
-            "data_y_upper": upper_y,
-            "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
-            # Aerodynamic performance of the lifting surface at
-            # an angle of attack of 0 (alpha=0).
-            # These CL0 and CD0 values are added to the CL and CD
-            # obtained from aerodynamic analysis of the surface to get
-            # the total CL and CD.
-            # These CL0 and CD0 values do not vary wrt alpha.
-            "CL0": 0.0,  # CL of the surface at alpha=0
-            "CD0": 0.0078,  # CD of the surface at alpha=0
-            # Airfoil properties for viscous drag calculation
-            "k_lam": 0.05,  # percentage of chord with laminar
-            # flow, used for viscous drag
-            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
-            "original_wingbox_airfoil_t_over_c": 0.12,
-            "c_max_t": 0.38,  # chordwise location of maximum thickness
-            "with_viscous": True,
-            "with_wave": False,  # if true, compute wave drag
-            # Structural values are based on aluminum 7075
-            "E": 73.1e9,  # [Pa] Young's modulus
-            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
-            "mrho": 2.78e3,  # [kg/m^3] material density
-            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
-            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
-            "wing_weight_ratio": 1.25,
-            "struct_weight_relief": True,
-            "distributed_fuel_weight": False,
-            # Constraints
-            "exact_failure_constraint": False,  # if false, use KS function
-            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
-            "span": 58.0,  # [m]
-        }
-
-        surfaces = [surf_dict]
-
-        # Create the problem and assign the model group
-        prob = om.Problem()
-
-        # Add problem information as an independent variables component
-        indep_var_comp = om.IndepVarComp()
-        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
-        indep_var_comp.add_output("alpha", val=0.0, units="deg")
-        indep_var_comp.add_output("Mach_number", val=0.85)
-        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
-        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
-        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
-        indep_var_comp.add_output("R", val=14.307e6, units="m")
-        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
-        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
-        indep_var_comp.add_output("load_factor", val=1.0)
-        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
-
-        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
-
-        # Loop over each surface in the surfaces list
-        for surface in surfaces:
-            # Get the surface name and create a group to contain components
-            # only for this surface
-            name = surface["name"]
-
-            aerostruct_group = AerostructGeometry(surface=surface)
-
-            # Add tmp_group to the problem with the name of the surface.
-            prob.model.add_subsystem(name, aerostruct_group)
-
-        # Loop through and add a certain number of aero points
-        for i in range(1):
-            point_name = "AS_point_{}".format(i)
-            # Connect the parameters within the model for each aero point
-
-            # Create the aero point group and add it to the model
-            AS_point = AerostructPoint(surfaces=surfaces)
-
-            prob.model.add_subsystem(point_name, AS_point)
-
-            # Connect flow properties to the analysis point
-            prob.model.connect("v", point_name + ".v")
-            prob.model.connect("alpha", point_name + ".alpha")
-            prob.model.connect("Mach_number", point_name + ".Mach_number")
-            prob.model.connect("re", point_name + ".re")
-            prob.model.connect("rho", point_name + ".rho")
-            prob.model.connect("CT", point_name + ".CT")
-            prob.model.connect("R", point_name + ".R")
-            prob.model.connect("W0", point_name + ".W0")
-            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
-            prob.model.connect("empty_cg", point_name + ".empty_cg")
-            prob.model.connect("load_factor", point_name + ".load_factor")
-
-            for _surface in surfaces:
-                com_name = point_name + "." + name + "_perf."
-                prob.model.connect(
-                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
-                )
-                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
-
-                # Connect aerodyamic mesh to coupled group mesh
-                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
-                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
-
-                # Connect performance calculation variables
-                prob.model.connect(name + ".nodes", com_name + "nodes")
-                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
-                prob.model.connect(
-                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
-                )
-
-                # Connect wingbox properties to von Mises stress calcs
-                prob.model.connect(name + ".Qz", com_name + "Qz")
-                prob.model.connect(name + ".J", com_name + "J")
-                prob.model.connect(name + ".A_enc", com_name + "A_enc")
-                prob.model.connect(name + ".htop", com_name + "htop")
-                prob.model.connect(name + ".hbottom", com_name + "hbottom")
-                prob.model.connect(name + ".hfront", com_name + "hfront")
-                prob.model.connect(name + ".hrear", com_name + "hrear")
-
-                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
-                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
-
-        prob.driver = om.ScipyOptimizeDriver()
-        prob.driver.options["tol"] = 1e-9
-
-        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
-
-        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
-        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
-        prob.model.add_design_var("wing.geometry.span", lower=55.0, upper=60.0, scaler=2e-2)
-
-        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
-        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
-
-        # Set up the problem
-        prob.setup()
-
-        prob.run_driver()
-        assert_near_equal(prob["AS_point_0.fuelburn"][0], 79151.03928720397, 1e-5)
-        assert_near_equal(prob["wing.structural_mass"][0] / 1.25, 13388.445732877735, 1e-5)
-        assert_near_equal(prob["wing.geometry.span"][0], 60.0, 1e-5)
-
-
-if __name__ == "__main__":
-    unittest.main()
+from openmdao.utils.assert_utils import assert_near_equal
+import unittest
+import numpy as np
+
+from openaerostruct.meshing.mesh_generator import generate_mesh
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+import openmdao.api as om
+
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+upper_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+lower_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+upper_y = np.array(
+    [
+        0.0447,
+        0.046,
+        0.0472,
+        0.0484,
+        0.0495,
+        0.0505,
+        0.0514,
+        0.0523,
+        0.0531,
+        0.0538,
+        0.0545,
+        0.0551,
+        0.0557,
+        0.0563,
+        0.0568,
+        0.0573,
+        0.0577,
+        0.0581,
+        0.0585,
+        0.0588,
+        0.0591,
+        0.0593,
+        0.0595,
+        0.0597,
+        0.0599,
+        0.06,
+        0.0601,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0601,
+        0.06,
+        0.0599,
+        0.0598,
+        0.0596,
+        0.0594,
+        0.0592,
+        0.0589,
+        0.0586,
+        0.0583,
+        0.058,
+        0.0576,
+        0.0572,
+        0.0568,
+        0.0563,
+        0.0558,
+        0.0553,
+        0.0547,
+        0.0541,
+    ],
+    dtype="complex128",
+)
+lower_y = np.array(
+    [
+        -0.0447,
+        -0.046,
+        -0.0473,
+        -0.0485,
+        -0.0496,
+        -0.0506,
+        -0.0515,
+        -0.0524,
+        -0.0532,
+        -0.054,
+        -0.0547,
+        -0.0554,
+        -0.056,
+        -0.0565,
+        -0.057,
+        -0.0575,
+        -0.0579,
+        -0.0583,
+        -0.0586,
+        -0.0589,
+        -0.0592,
+        -0.0594,
+        -0.0595,
+        -0.0596,
+        -0.0597,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0597,
+        -0.0596,
+        -0.0594,
+        -0.0592,
+        -0.0589,
+        -0.0586,
+        -0.0582,
+        -0.0578,
+        -0.0573,
+        -0.0567,
+        -0.0561,
+        -0.0554,
+        -0.0546,
+        -0.0538,
+        -0.0529,
+        -0.0519,
+        -0.0509,
+        -0.0497,
+        -0.0485,
+        -0.0472,
+        -0.0458,
+        -0.0444,
+    ],
+    dtype="complex128",
+)
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        # Create a dictionary to store options about the surface
+        mesh_dict = {
+            "num_y": 5,
+            "num_x": 3,
+            "wing_type": "CRM",
+            "symmetry": True,
+            "num_twist_cp": 6,
+            "chord_cos_spacing": 0,
+            "span_cos_spacing": 0,
+        }
+
+        mesh, twist_cp = generate_mesh(mesh_dict)
+
+        surf_dict = {
+            # Wing definition
+            "name": "wing",  # name of the surface
+            "symmetry": True,  # if true, model one half of wing
+            # reflected across the plane y = 0
+            "S_ref_type": "wetted",  # how we compute the wing area,
+            # can be 'wetted' or 'projected'
+            "fem_model_type": "wingbox",
+            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+            "mesh": mesh,
+            "data_x_upper": upper_x,
+            "data_x_lower": lower_x,
+            "data_y_upper": upper_y,
+            "data_y_lower": lower_y,
+            # Aerodynamic performance of the lifting surface at
+            # an angle of attack of 0 (alpha=0).
+            # These CL0 and CD0 values are added to the CL and CD
+            # obtained from aerodynamic analysis of the surface to get
+            # the total CL and CD.
+            # These CL0 and CD0 values do not vary wrt alpha.
+            "CL0": 0.0,  # CL of the surface at alpha=0
+            "CD0": 0.0078,  # CD of the surface at alpha=0
+            # Airfoil properties for viscous drag calculation
+            "k_lam": 0.05,  # percentage of chord with laminar
+            # flow, used for viscous drag
+            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+            "original_wingbox_airfoil_t_over_c": 0.12,
+            "c_max_t": 0.38,  # chordwise location of maximum thickness
+            "with_viscous": True,
+            "with_wave": False,  # if true, compute wave drag
+            # Structural values are based on aluminum 7075
+            "E": 73.1e9,  # [Pa] Young's modulus
+            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
+            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "mrho": 2.78e3,  # [kg/m^3] material density
+            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
+            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
+            "wing_weight_ratio": 1.25,
+            "struct_weight_relief": True,
+            "distributed_fuel_weight": False,
+            # Constraints
+            "exact_failure_constraint": False,  # if false, use KS function
+            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+            "span": 58.0,  # [m]
+        }
+
+        surfaces = [surf_dict]
+
+        # Create the problem and assign the model group
+        prob = om.Problem()
+
+        # Add problem information as an independent variables component
+        indep_var_comp = om.IndepVarComp()
+        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
+        indep_var_comp.add_output("alpha", val=0.0, units="deg")
+        indep_var_comp.add_output("Mach_number", val=0.85)
+        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
+        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+        indep_var_comp.add_output("R", val=14.307e6, units="m")
+        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+        indep_var_comp.add_output("load_factor", val=1.0)
+        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+
+        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+        # Loop over each surface in the surfaces list
+        for surface in surfaces:
+            # Get the surface name and create a group to contain components
+            # only for this surface
+            name = surface["name"]
+
+            aerostruct_group = AerostructGeometry(surface=surface)
+
+            # Add tmp_group to the problem with the name of the surface.
+            prob.model.add_subsystem(name, aerostruct_group)
+
+        # Loop through and add a certain number of aero points
+        for i in range(1):
+            point_name = "AS_point_{}".format(i)
+            # Connect the parameters within the model for each aero point
+
+            # Create the aero point group and add it to the model
+            AS_point = AerostructPoint(surfaces=surfaces)
+
+            prob.model.add_subsystem(point_name, AS_point)
+
+            # Connect flow properties to the analysis point
+            prob.model.connect("v", point_name + ".v")
+            prob.model.connect("alpha", point_name + ".alpha")
+            prob.model.connect("Mach_number", point_name + ".Mach_number")
+            prob.model.connect("re", point_name + ".re")
+            prob.model.connect("rho", point_name + ".rho")
+            prob.model.connect("CT", point_name + ".CT")
+            prob.model.connect("R", point_name + ".R")
+            prob.model.connect("W0", point_name + ".W0")
+            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+            prob.model.connect("empty_cg", point_name + ".empty_cg")
+            prob.model.connect("load_factor", point_name + ".load_factor")
+
+            for _surface in surfaces:
+                com_name = point_name + "." + name + "_perf."
+                prob.model.connect(
+                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+                )
+                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+                # Connect aerodyamic mesh to coupled group mesh
+                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+                # Connect performance calculation variables
+                prob.model.connect(name + ".nodes", com_name + "nodes")
+                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+                prob.model.connect(
+                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
+                )
+
+                # Connect wingbox properties to von Mises stress calcs
+                prob.model.connect(name + ".Qz", com_name + "Qz")
+                prob.model.connect(name + ".J", com_name + "J")
+                prob.model.connect(name + ".A_enc", com_name + "A_enc")
+                prob.model.connect(name + ".htop", com_name + "htop")
+                prob.model.connect(name + ".hbottom", com_name + "hbottom")
+                prob.model.connect(name + ".hfront", com_name + "hfront")
+                prob.model.connect(name + ".hrear", com_name + "hrear")
+
+                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+        prob.driver = om.ScipyOptimizeDriver()
+        prob.driver.options["tol"] = 1e-9
+
+        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+        prob.model.add_design_var("wing.geometry.span", lower=55.0, upper=60.0, scaler=2e-2)
+
+        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+        # Set up the problem
+        prob.setup()
+
+        prob.run_driver()
+        assert_near_equal(prob["AS_point_0.fuelburn"][0], 79151.03928720397, 1e-5)
+        assert_near_equal(prob["wing.structural_mass"][0] / 1.25, 13388.445732877735, 1e-5)
+        assert_near_equal(prob["wing.geometry.span"][0], 60.0, 1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py b/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
index 4a423271d..8368ea880 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
@@ -1,441 +1,440 @@
-from openmdao.utils.assert_utils import assert_near_equal
-from openaerostruct.utils.testing import assert_opt_successful
-import unittest
-import numpy as np
-
-from openaerostruct.meshing.mesh_generator import generate_mesh
-
-from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
-
-import openmdao.api as om
-from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
-
-
-# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
-# These should be for an airfoil with the chord scaled to 1.
-# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
-# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
-# The first and last x-coordinates of the upper and lower skins must be the same
-
-upper_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-lower_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-upper_y = np.array(
-    [
-        0.0447,
-        0.046,
-        0.0472,
-        0.0484,
-        0.0495,
-        0.0505,
-        0.0514,
-        0.0523,
-        0.0531,
-        0.0538,
-        0.0545,
-        0.0551,
-        0.0557,
-        0.0563,
-        0.0568,
-        0.0573,
-        0.0577,
-        0.0581,
-        0.0585,
-        0.0588,
-        0.0591,
-        0.0593,
-        0.0595,
-        0.0597,
-        0.0599,
-        0.06,
-        0.0601,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0601,
-        0.06,
-        0.0599,
-        0.0598,
-        0.0596,
-        0.0594,
-        0.0592,
-        0.0589,
-        0.0586,
-        0.0583,
-        0.058,
-        0.0576,
-        0.0572,
-        0.0568,
-        0.0563,
-        0.0558,
-        0.0553,
-        0.0547,
-        0.0541,
-    ],
-    dtype="complex128",
-)
-lower_y = np.array(
-    [
-        -0.0447,
-        -0.046,
-        -0.0473,
-        -0.0485,
-        -0.0496,
-        -0.0506,
-        -0.0515,
-        -0.0524,
-        -0.0532,
-        -0.054,
-        -0.0547,
-        -0.0554,
-        -0.056,
-        -0.0565,
-        -0.057,
-        -0.0575,
-        -0.0579,
-        -0.0583,
-        -0.0586,
-        -0.0589,
-        -0.0592,
-        -0.0594,
-        -0.0595,
-        -0.0596,
-        -0.0597,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0597,
-        -0.0596,
-        -0.0594,
-        -0.0592,
-        -0.0589,
-        -0.0586,
-        -0.0582,
-        -0.0578,
-        -0.0573,
-        -0.0567,
-        -0.0561,
-        -0.0554,
-        -0.0546,
-        -0.0538,
-        -0.0529,
-        -0.0519,
-        -0.0509,
-        -0.0497,
-        -0.0485,
-        -0.0472,
-        -0.0458,
-        -0.0444,
-    ],
-    dtype="complex128",
-)
-
-
-class Test(unittest.TestCase):
-    def test(self):
-        """
-        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
-        """
-
-        # Create a dictionary to store options about the surface
-        mesh_dict = {
-            "num_y": 7,
-            "num_x": 2,
-            "wing_type": "CRM",
-            "symmetry": True,
-            "num_twist_cp": 6,
-            "chord_cos_spacing": 0,
-            "span_cos_spacing": 0,
-        }
-
-        mesh, twist_cp = generate_mesh(mesh_dict)
-
-        surf_dict = {
-            # Wing definition
-            "name": "wing",  # name of the surface
-            "symmetry": True,  # if true, model one half of wing
-            # reflected across the plane y = 0
-            "S_ref_type": "wetted",  # how we compute the wing area,
-            # can be 'wetted' or 'projected'
-            "fem_model_type": "wingbox",
-            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
-            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
-            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
-            "mesh": mesh,
-            "data_x_upper": upper_x,
-            "data_x_lower": lower_x,
-            "data_y_upper": upper_y,
-            "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
-            # Aerodynamic performance of the lifting surface at
-            # an angle of attack of 0 (alpha=0).
-            # These CL0 and CD0 values are added to the CL and CD
-            # obtained from aerodynamic analysis of the surface to get
-            # the total CL and CD.
-            # These CL0 and CD0 values do not vary wrt alpha.
-            "CL0": 0.0,  # CL of the surface at alpha=0
-            "CD0": 0.0078,  # CD of the surface at alpha=0
-            # Airfoil properties for viscous drag calculation
-            "k_lam": 0.05,  # percentage of chord with laminar
-            # flow, used for viscous drag
-            "t_over_c_cp": 0.12 * np.ones(6),
-            "original_wingbox_airfoil_t_over_c": 0.12,
-            "c_max_t": 0.38,  # chordwise location of maximum thickness
-            "with_viscous": True,
-            "with_wave": True,  # if true, compute wave drag
-            # Structural values are based on aluminum 7075
-            "E": 73.1e9,  # [Pa] Young's modulus
-            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
-            "mrho": 2.78e3,  # [kg/m^3] material density
-            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
-            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
-            "wing_weight_ratio": 1.25,
-            "struct_weight_relief": True,
-            "distributed_fuel_weight": False,
-            # Constraints
-            "exact_failure_constraint": False,  # if false, use KS function
-            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
-            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
-        }
-
-        surfaces = [surf_dict]
-
-        # Create the problem and assign the model group
-        prob = om.Problem()
-
-        # Add problem information as an independent variables component
-        indep_var_comp = om.IndepVarComp()
-        Mach = 0.77
-        indep_var_comp.add_output("v", val=Mach * 295.07, units="m/s")
-        indep_var_comp.add_output("alpha", val=0.0, units="deg")
-        indep_var_comp.add_output("Mach_number", val=Mach)
-        indep_var_comp.add_output("re", val=0.348 * 295.07 * Mach * 1.0 / (1.43 * 1e-5), units="1/m")
-        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
-        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
-        indep_var_comp.add_output("R", val=14.307e6, units="m")
-        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
-        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
-        indep_var_comp.add_output("load_factor", val=1.0)
-        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
-
-        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
-
-        # Loop over each surface in the surfaces list
-        for surface in surfaces:
-            # Get the surface name and create a group to contain components
-            # only for this surface
-            name = surface["name"]
-
-            aerostruct_group = AerostructGeometry(surface=surface)
-
-            # Add tmp_group to the problem with the name of the surface.
-            prob.model.add_subsystem(name, aerostruct_group)
-
-        # Loop through and add a certain number of aero points
-        for i in range(1):
-            point_name = "AS_point_{}".format(i)
-            # Connect the parameters within the model for each aero point
-
-            # Create the aero point group and add it to the model
-            AS_point = AerostructPoint(surfaces=surfaces)
-
-            prob.model.add_subsystem(point_name, AS_point)
-
-            # Connect flow properties to the analysis point
-            prob.model.connect("v", point_name + ".v")
-            prob.model.connect("alpha", point_name + ".alpha")
-            prob.model.connect("Mach_number", point_name + ".Mach_number")
-            prob.model.connect("re", point_name + ".re")
-            prob.model.connect("rho", point_name + ".rho")
-            prob.model.connect("CT", point_name + ".CT")
-            prob.model.connect("R", point_name + ".R")
-            prob.model.connect("W0", point_name + ".W0")
-            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
-            prob.model.connect("empty_cg", point_name + ".empty_cg")
-            prob.model.connect("load_factor", point_name + ".load_factor")
-
-            for _surface in surfaces:
-                com_name = point_name + "." + name + "_perf."
-                prob.model.connect(
-                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
-                )
-                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
-
-                # Connect aerodyamic mesh to coupled group mesh
-                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
-                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
-
-                # Connect performance calculation variables
-                prob.model.connect(name + ".nodes", com_name + "nodes")
-                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
-                prob.model.connect(
-                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
-                )
-
-                # Connect wingbox properties to von Mises stress calcs
-                prob.model.connect(name + ".Qz", com_name + "Qz")
-                prob.model.connect(name + ".J", com_name + "J")
-                prob.model.connect(name + ".A_enc", com_name + "A_enc")
-                prob.model.connect(name + ".htop", com_name + "htop")
-                prob.model.connect(name + ".hbottom", com_name + "hbottom")
-                prob.model.connect(name + ".hfront", com_name + "hfront")
-                prob.model.connect(name + ".hrear", com_name + "hrear")
-
-                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
-                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
-
-            # =======================================================================================
-            # Here we add the fuel volume constraint componenet to the model
-            # =======================================================================================
-            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
-            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
-            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
-            # =======================================================================================
-            # =======================================================================================
-
-        prob.driver = om.ScipyOptimizeDriver()
-        prob.driver.options["tol"] = 1e-9
-
-        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
-
-        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
-        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.06, upper=0.2, scaler=10.0)
-
-        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
-        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
-
-        # =======================================================================================
-        # Here we add the fuel volume constraint
-        # =======================================================================================
-        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
-        # =======================================================================================
-        # =======================================================================================
-
-        # Set up the problem
-        prob.setup()
-
-        optResult = prob.run_driver()
-
-        assert_opt_successful(self, optResult)
-        assert_near_equal(prob["AS_point_0.fuelburn"][0], 85400.83793743863, 1e-5)
-        assert_near_equal(prob["wing.structural_mass"][0], 13149.34611487464, 1e-5)
-        assert_near_equal(prob["AS_point_0.CL"][0], 0.5, 1e-5)
-
-
-if __name__ == "__main__":
-    unittest.main()
+from openmdao.utils.assert_utils import assert_near_equal
+from openaerostruct.utils.testing import assert_opt_successful
+import unittest
+import numpy as np
+
+from openaerostruct.meshing.mesh_generator import generate_mesh
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+import openmdao.api as om
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+upper_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+lower_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+upper_y = np.array(
+    [
+        0.0447,
+        0.046,
+        0.0472,
+        0.0484,
+        0.0495,
+        0.0505,
+        0.0514,
+        0.0523,
+        0.0531,
+        0.0538,
+        0.0545,
+        0.0551,
+        0.0557,
+        0.0563,
+        0.0568,
+        0.0573,
+        0.0577,
+        0.0581,
+        0.0585,
+        0.0588,
+        0.0591,
+        0.0593,
+        0.0595,
+        0.0597,
+        0.0599,
+        0.06,
+        0.0601,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0601,
+        0.06,
+        0.0599,
+        0.0598,
+        0.0596,
+        0.0594,
+        0.0592,
+        0.0589,
+        0.0586,
+        0.0583,
+        0.058,
+        0.0576,
+        0.0572,
+        0.0568,
+        0.0563,
+        0.0558,
+        0.0553,
+        0.0547,
+        0.0541,
+    ],
+    dtype="complex128",
+)
+lower_y = np.array(
+    [
+        -0.0447,
+        -0.046,
+        -0.0473,
+        -0.0485,
+        -0.0496,
+        -0.0506,
+        -0.0515,
+        -0.0524,
+        -0.0532,
+        -0.054,
+        -0.0547,
+        -0.0554,
+        -0.056,
+        -0.0565,
+        -0.057,
+        -0.0575,
+        -0.0579,
+        -0.0583,
+        -0.0586,
+        -0.0589,
+        -0.0592,
+        -0.0594,
+        -0.0595,
+        -0.0596,
+        -0.0597,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0597,
+        -0.0596,
+        -0.0594,
+        -0.0592,
+        -0.0589,
+        -0.0586,
+        -0.0582,
+        -0.0578,
+        -0.0573,
+        -0.0567,
+        -0.0561,
+        -0.0554,
+        -0.0546,
+        -0.0538,
+        -0.0529,
+        -0.0519,
+        -0.0509,
+        -0.0497,
+        -0.0485,
+        -0.0472,
+        -0.0458,
+        -0.0444,
+    ],
+    dtype="complex128",
+)
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        """
+        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
+        """
+
+        # Create a dictionary to store options about the surface
+        mesh_dict = {
+            "num_y": 7,
+            "num_x": 2,
+            "wing_type": "CRM",
+            "symmetry": True,
+            "num_twist_cp": 6,
+            "chord_cos_spacing": 0,
+            "span_cos_spacing": 0,
+        }
+
+        mesh, twist_cp = generate_mesh(mesh_dict)
+
+        surf_dict = {
+            # Wing definition
+            "name": "wing",  # name of the surface
+            "symmetry": True,  # if true, model one half of wing
+            # reflected across the plane y = 0
+            "S_ref_type": "wetted",  # how we compute the wing area,
+            # can be 'wetted' or 'projected'
+            "fem_model_type": "wingbox",
+            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+            "mesh": mesh,
+            "data_x_upper": upper_x,
+            "data_x_lower": lower_x,
+            "data_y_upper": upper_y,
+            "data_y_lower": lower_y,
+            # Aerodynamic performance of the lifting surface at
+            # an angle of attack of 0 (alpha=0).
+            # These CL0 and CD0 values are added to the CL and CD
+            # obtained from aerodynamic analysis of the surface to get
+            # the total CL and CD.
+            # These CL0 and CD0 values do not vary wrt alpha.
+            "CL0": 0.0,  # CL of the surface at alpha=0
+            "CD0": 0.0078,  # CD of the surface at alpha=0
+            # Airfoil properties for viscous drag calculation
+            "k_lam": 0.05,  # percentage of chord with laminar
+            # flow, used for viscous drag
+            "t_over_c_cp": 0.12 * np.ones(6),
+            "original_wingbox_airfoil_t_over_c": 0.12,
+            "c_max_t": 0.38,  # chordwise location of maximum thickness
+            "with_viscous": True,
+            "with_wave": True,  # if true, compute wave drag
+            # Structural values are based on aluminum 7075
+            "E": 73.1e9,  # [Pa] Young's modulus
+            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
+            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "mrho": 2.78e3,  # [kg/m^3] material density
+            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
+            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
+            "wing_weight_ratio": 1.25,
+            "struct_weight_relief": True,
+            "distributed_fuel_weight": False,
+            # Constraints
+            "exact_failure_constraint": False,  # if false, use KS function
+            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+        }
+
+        surfaces = [surf_dict]
+
+        # Create the problem and assign the model group
+        prob = om.Problem()
+
+        # Add problem information as an independent variables component
+        indep_var_comp = om.IndepVarComp()
+        Mach = 0.77
+        indep_var_comp.add_output("v", val=Mach * 295.07, units="m/s")
+        indep_var_comp.add_output("alpha", val=0.0, units="deg")
+        indep_var_comp.add_output("Mach_number", val=Mach)
+        indep_var_comp.add_output("re", val=0.348 * 295.07 * Mach * 1.0 / (1.43 * 1e-5), units="1/m")
+        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+        indep_var_comp.add_output("R", val=14.307e6, units="m")
+        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+        indep_var_comp.add_output("load_factor", val=1.0)
+        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+
+        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+        # Loop over each surface in the surfaces list
+        for surface in surfaces:
+            # Get the surface name and create a group to contain components
+            # only for this surface
+            name = surface["name"]
+
+            aerostruct_group = AerostructGeometry(surface=surface)
+
+            # Add tmp_group to the problem with the name of the surface.
+            prob.model.add_subsystem(name, aerostruct_group)
+
+        # Loop through and add a certain number of aero points
+        for i in range(1):
+            point_name = "AS_point_{}".format(i)
+            # Connect the parameters within the model for each aero point
+
+            # Create the aero point group and add it to the model
+            AS_point = AerostructPoint(surfaces=surfaces)
+
+            prob.model.add_subsystem(point_name, AS_point)
+
+            # Connect flow properties to the analysis point
+            prob.model.connect("v", point_name + ".v")
+            prob.model.connect("alpha", point_name + ".alpha")
+            prob.model.connect("Mach_number", point_name + ".Mach_number")
+            prob.model.connect("re", point_name + ".re")
+            prob.model.connect("rho", point_name + ".rho")
+            prob.model.connect("CT", point_name + ".CT")
+            prob.model.connect("R", point_name + ".R")
+            prob.model.connect("W0", point_name + ".W0")
+            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+            prob.model.connect("empty_cg", point_name + ".empty_cg")
+            prob.model.connect("load_factor", point_name + ".load_factor")
+
+            for _surface in surfaces:
+                com_name = point_name + "." + name + "_perf."
+                prob.model.connect(
+                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+                )
+                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+                # Connect aerodyamic mesh to coupled group mesh
+                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+                # Connect performance calculation variables
+                prob.model.connect(name + ".nodes", com_name + "nodes")
+                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+                prob.model.connect(
+                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
+                )
+
+                # Connect wingbox properties to von Mises stress calcs
+                prob.model.connect(name + ".Qz", com_name + "Qz")
+                prob.model.connect(name + ".J", com_name + "J")
+                prob.model.connect(name + ".A_enc", com_name + "A_enc")
+                prob.model.connect(name + ".htop", com_name + "htop")
+                prob.model.connect(name + ".hbottom", com_name + "hbottom")
+                prob.model.connect(name + ".hfront", com_name + "hfront")
+                prob.model.connect(name + ".hrear", com_name + "hrear")
+
+                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+            # =======================================================================================
+            # Here we add the fuel volume constraint componenet to the model
+            # =======================================================================================
+            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+            # =======================================================================================
+            # =======================================================================================
+
+        prob.driver = om.ScipyOptimizeDriver()
+        prob.driver.options["tol"] = 1e-9
+
+        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.06, upper=0.2, scaler=10.0)
+
+        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+        # =======================================================================================
+        # Here we add the fuel volume constraint
+        # =======================================================================================
+        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+        # =======================================================================================
+        # =======================================================================================
+
+        # Set up the problem
+        prob.setup()
+
+        optResult = prob.run_driver()
+
+        assert_opt_successful(self, optResult)
+        assert_near_equal(prob["AS_point_0.fuelburn"][0], 85400.83793743863, 1e-5)
+        assert_near_equal(prob["wing.structural_mass"][0], 13149.34611487464, 1e-5)
+        assert_near_equal(prob["AS_point_0.CL"][0], 0.5, 1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_multi_2_sec_AS.py b/tests/integration_tests/test_multi_2_sec_AS.py
index 62ebfc61c..8b2cf8260 100644
--- a/tests/integration_tests/test_multi_2_sec_AS.py
+++ b/tests/integration_tests/test_multi_2_sec_AS.py
@@ -1,6 +1,7 @@
 """We verify the results of the two-section aerostructural optimization using both the construction and constraint
 methods of joining sections. The result should be the same so we compare with the same reference value. We also perform
-the same optimization for an asymmetical two-section mesh which is compared against its own reference value."""
+the same optimization for an asymmetical two-section mesh which is compared against its own reference value.
+"""
 
 from openmdao.utils.assert_utils import assert_near_equal
 import unittest
diff --git a/tests/integration_tests/test_multi_single.py b/tests/integration_tests/test_multi_single.py
index f2cef9d20..ea0116dba 100644
--- a/tests/integration_tests/test_multi_single.py
+++ b/tests/integration_tests/test_multi_single.py
@@ -3,6 +3,7 @@
 
 import openmdao
 
+
 # skip this test on OpenMDAO 3.40.0 because it fails due to a bug in OM 3.40.0
 @unittest.skipIf(openmdao.__version__ == "3.40.0", "Skipped on OpenMDAO 3.40.0")
 class Test(unittest.TestCase):
diff --git a/tests/integration_tests/test_multi_single_AS.py b/tests/integration_tests/test_multi_single_AS.py
index fa31dca63..164d0dbd4 100644
--- a/tests/integration_tests/test_multi_single_AS.py
+++ b/tests/integration_tests/test_multi_single_AS.py
@@ -1,5 +1,6 @@
 """We verify the results of the two-section aerostructural analysis to the same wing analysed with single section
-geometry. We verify the results are the same."""
+geometry. We verify the results are the same.
+"""
 
 from openmdao.utils.assert_utils import assert_near_equal
 import unittest
diff --git a/tests/integration_tests/test_multipoint_wingbox_aerostruct.py b/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
index 120534198..8baed940d 100644
--- a/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
+++ b/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
@@ -278,7 +278,6 @@ def test(self):
             "data_x_lower": lower_x,
             "data_y_upper": upper_y,
             "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
             # Aerodynamic performance of the lifting surface at
             # an angle of attack of 0 (alpha=0).
             # These CL0 and CD0 values are added to the CL and CD
diff --git a/tests/integration_tests/test_multipoint_wingbox_derivs.py b/tests/integration_tests/test_multipoint_wingbox_derivs.py
index f190f32f1..0bae60c03 100644
--- a/tests/integration_tests/test_multipoint_wingbox_derivs.py
+++ b/tests/integration_tests/test_multipoint_wingbox_derivs.py
@@ -1,472 +1,471 @@
-import unittest
-import numpy as np
-
-from openaerostruct.meshing.mesh_generator import generate_mesh
-
-from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
-
-import openmdao.api as om
-from openmdao.utils.assert_utils import assert_check_partials
-from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
-
-# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
-# These should be for an airfoil with the chord scaled to 1.
-# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
-# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
-# The first and last x-coordinates of the upper and lower skins must be the same
-
-upper_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-lower_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ],
-    dtype="complex128",
-)
-upper_y = np.array(
-    [
-        0.0447,
-        0.046,
-        0.0472,
-        0.0484,
-        0.0495,
-        0.0505,
-        0.0514,
-        0.0523,
-        0.0531,
-        0.0538,
-        0.0545,
-        0.0551,
-        0.0557,
-        0.0563,
-        0.0568,
-        0.0573,
-        0.0577,
-        0.0581,
-        0.0585,
-        0.0588,
-        0.0591,
-        0.0593,
-        0.0595,
-        0.0597,
-        0.0599,
-        0.06,
-        0.0601,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0601,
-        0.06,
-        0.0599,
-        0.0598,
-        0.0596,
-        0.0594,
-        0.0592,
-        0.0589,
-        0.0586,
-        0.0583,
-        0.058,
-        0.0576,
-        0.0572,
-        0.0568,
-        0.0563,
-        0.0558,
-        0.0553,
-        0.0547,
-        0.0541,
-    ],
-    dtype="complex128",
-)
-lower_y = np.array(
-    [
-        -0.0447,
-        -0.046,
-        -0.0473,
-        -0.0485,
-        -0.0496,
-        -0.0506,
-        -0.0515,
-        -0.0524,
-        -0.0532,
-        -0.054,
-        -0.0547,
-        -0.0554,
-        -0.056,
-        -0.0565,
-        -0.057,
-        -0.0575,
-        -0.0579,
-        -0.0583,
-        -0.0586,
-        -0.0589,
-        -0.0592,
-        -0.0594,
-        -0.0595,
-        -0.0596,
-        -0.0597,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0597,
-        -0.0596,
-        -0.0594,
-        -0.0592,
-        -0.0589,
-        -0.0586,
-        -0.0582,
-        -0.0578,
-        -0.0573,
-        -0.0567,
-        -0.0561,
-        -0.0554,
-        -0.0546,
-        -0.0538,
-        -0.0529,
-        -0.0519,
-        -0.0509,
-        -0.0497,
-        -0.0485,
-        -0.0472,
-        -0.0458,
-        -0.0444,
-    ],
-    dtype="complex128",
-)
-
-
-class Test(unittest.TestCase):
-    def test(self):
-        """
-        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
-        """
-
-        # Create a dictionary to store options about the surface
-        mesh_dict = {
-            "num_y": 7,
-            "num_x": 2,
-            "wing_type": "CRM",
-            "symmetry": True,
-            "num_twist_cp": 6,
-            "chord_cos_spacing": 0,
-            "span_cos_spacing": 0,
-        }
-
-        mesh, twist_cp = generate_mesh(mesh_dict)
-
-        surf_dict = {
-            # Wing definition
-            "name": "wing",  # name of the surface
-            "symmetry": True,  # if true, model one half of wing
-            # reflected across the plane y = 0
-            "S_ref_type": "wetted",  # how we compute the wing area,
-            # can be 'wetted' or 'projected'
-            "fem_model_type": "wingbox",
-            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
-            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
-            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
-            "mesh": mesh,
-            "data_x_upper": upper_x,
-            "data_x_lower": lower_x,
-            "data_y_upper": upper_y,
-            "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
-            # Aerodynamic performance of the lifting surface at
-            # an angle of attack of 0 (alpha=0).
-            # These CL0 and CD0 values are added to the CL and CD
-            # obtained from aerodynamic analysis of the surface to get
-            # the total CL and CD.
-            # These CL0 and CD0 values do not vary wrt alpha.
-            "CL0": 0.0,  # CL of the surface at alpha=0
-            "CD0": 0.0078,  # CD of the surface at alpha=0
-            # Airfoil properties for viscous drag calculation
-            "k_lam": 0.05,  # percentage of chord with laminar
-            # flow, used for viscous drag
-            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
-            "original_wingbox_airfoil_t_over_c": 0.12,
-            "c_max_t": 0.38,  # chordwise location of maximum thickness
-            "with_viscous": True,
-            "with_wave": True,  # if true, compute wave drag
-            # Structural values are based on aluminum 7075
-            "E": 73.1e9,  # [Pa] Young's modulus
-            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
-            "mrho": 2.78e3,  # [kg/m^3] material density
-            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
-            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
-            "wing_weight_ratio": 1.25,
-            "struct_weight_relief": True,
-            "distributed_fuel_weight": True,
-            # Constraints
-            "exact_failure_constraint": False,  # if false, use KS function
-            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
-            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
-        }
-
-        surfaces = [surf_dict]
-
-        # Create the problem and assign the model group
-        prob = om.Problem()
-
-        # Add problem information as an independent variables component
-        indep_var_comp = om.IndepVarComp()
-        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
-        indep_var_comp.add_output("alpha", val=0.0, units="deg")
-        indep_var_comp.add_output("Mach_number", val=0.85)
-        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
-        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
-        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
-        indep_var_comp.add_output("R", val=14.307e6, units="m")
-        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
-        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
-        indep_var_comp.add_output("load_factor", val=np.array([1.0, 2.5]))
-        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
-        indep_var_comp.add_output("fuel_mass", val=10000.0, units="kg")
-
-        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
-
-        # Loop over each surface in the surfaces list
-        for surface in surfaces:
-            # Get the surface name and create a group to contain components
-            # only for this surface
-            name = surface["name"]
-
-            aerostruct_group = AerostructGeometry(surface=surface)
-
-            # Add tmp_group to the problem with the name of the surface.
-            prob.model.add_subsystem(name, aerostruct_group)
-
-        # Loop through and add a certain number of aero points
-        for i in range(2):
-            point_name = "AS_point_{}".format(i)
-            # Connect the parameters within the model for each aero point
-
-            # Create the aero point group and add it to the model
-            AS_point = AerostructPoint(surfaces=surfaces, internally_connect_fuelburn=False)
-
-            prob.model.add_subsystem(point_name, AS_point)
-
-            # Connect flow properties to the analysis point
-            prob.model.connect("v", point_name + ".v")
-            prob.model.connect("alpha", point_name + ".alpha")
-            prob.model.connect("Mach_number", point_name + ".Mach_number")
-            prob.model.connect("re", point_name + ".re")
-            prob.model.connect("rho", point_name + ".rho")
-            prob.model.connect("CT", point_name + ".CT")
-            prob.model.connect("R", point_name + ".R")
-            prob.model.connect("W0", point_name + ".W0")
-            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
-            prob.model.connect("empty_cg", point_name + ".empty_cg")
-            prob.model.connect("load_factor", point_name + ".load_factor", src_indices=[i])
-            prob.model.connect("fuel_mass", point_name + ".total_perf.L_equals_W.fuelburn")
-            prob.model.connect("fuel_mass", point_name + ".total_perf.CG.fuelburn")
-
-            for _surface in surfaces:
-                prob.model.connect("load_factor", point_name + ".coupled.load_factor", src_indices=[i])
-
-                com_name = point_name + "." + name + "_perf."
-                prob.model.connect(
-                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
-                )
-                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
-
-                # Connect aerodyamic mesh to coupled group mesh
-                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
-                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
-
-                # Connect performance calculation variables
-                prob.model.connect(name + ".nodes", com_name + "nodes")
-                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
-                prob.model.connect(
-                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
-                )
-
-                # Connect wingbox properties to von Mises stress calcs
-                prob.model.connect(name + ".Qz", com_name + "Qz")
-                prob.model.connect(name + ".J", com_name + "J")
-                prob.model.connect(name + ".A_enc", com_name + "A_enc")
-                prob.model.connect(name + ".htop", com_name + "htop")
-                prob.model.connect(name + ".hbottom", com_name + "hbottom")
-                prob.model.connect(name + ".hfront", com_name + "hfront")
-                prob.model.connect(name + ".hrear", com_name + "hrear")
-
-                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
-                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
-
-        # =======================================================================================
-        # Here we add the fuel volume constraint componenet to the model
-        # =======================================================================================
-        prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
-        prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
-
-        prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
-        prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
-        prob.model.connect("fuel_mass", "AS_point_0.coupled.wing.struct_states.fuel_mass")
-
-        prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_1.coupled.wing.struct_states.fuel_vols")
-        prob.model.connect("fuel_mass", "AS_point_1.coupled.wing.struct_states.fuel_mass")
-
-        comp = om.ExecComp("fuel_diff = (fuel_mass - fuelburn) / fuelburn", units="kg")
-        prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
-        prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
-
-        comp = om.ExecComp("fuel_diff_25 = (fuel_mass - fuelburn) / fuelburn", units="kg")
-        prob.model.add_subsystem("fuel_diff_25", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff_25"])
-        prob.model.connect("AS_point_1.fuelburn", "fuel_diff_25.fuelburn")
-        # =======================================================================================
-        # =======================================================================================
-
-        prob.driver = om.ScipyOptimizeDriver()
-        prob.driver.options["tol"] = 1e-9
-        prob.driver.options["maxiter"] = 5
-
-        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
-
-        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
-        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
-        prob.model.add_design_var("fuel_mass", lower=0.0, upper=2e5, scaler=1e-5)
-
-        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
-        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
-
-        # =======================================================================================
-        # Here we add the fuel volume constraint
-        # =======================================================================================
-        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
-        prob.model.add_constraint("fuel_diff", equals=0.0)
-        prob.model.add_constraint("fuel_diff_25", equals=0.0)
-        # =======================================================================================
-        # =======================================================================================
-
-        # Set up the problem
-        prob.setup()
-
-        # om.view_model(prob)
-
-        prob.run_model()
-
-        # Check the partials at the initial point in the design space,
-        # only care about relative error
-        # the list of components that uses CS to compute derivatives. We exclude them from check_partials
-        excludes_list = ["wing.wingbox_group.wingbox", "*.fuel_vol", "*.fuel_loads", "*.vonmises", "fuel_vol_delta"]
-        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
-        assert_check_partials(data, atol=1e20, rtol=1e-6)
-
-        # Run the optimizer for 5 iterations
-        prob.run_driver()
-
-        # Check the partials at this point in the design space
-        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
-        assert_check_partials(data, atol=1e20, rtol=1e-6)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+import numpy as np
+
+from openaerostruct.meshing.mesh_generator import generate_mesh
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+import openmdao.api as om
+from openmdao.utils.assert_utils import assert_check_partials
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+upper_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+lower_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ],
+    dtype="complex128",
+)
+upper_y = np.array(
+    [
+        0.0447,
+        0.046,
+        0.0472,
+        0.0484,
+        0.0495,
+        0.0505,
+        0.0514,
+        0.0523,
+        0.0531,
+        0.0538,
+        0.0545,
+        0.0551,
+        0.0557,
+        0.0563,
+        0.0568,
+        0.0573,
+        0.0577,
+        0.0581,
+        0.0585,
+        0.0588,
+        0.0591,
+        0.0593,
+        0.0595,
+        0.0597,
+        0.0599,
+        0.06,
+        0.0601,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0601,
+        0.06,
+        0.0599,
+        0.0598,
+        0.0596,
+        0.0594,
+        0.0592,
+        0.0589,
+        0.0586,
+        0.0583,
+        0.058,
+        0.0576,
+        0.0572,
+        0.0568,
+        0.0563,
+        0.0558,
+        0.0553,
+        0.0547,
+        0.0541,
+    ],
+    dtype="complex128",
+)
+lower_y = np.array(
+    [
+        -0.0447,
+        -0.046,
+        -0.0473,
+        -0.0485,
+        -0.0496,
+        -0.0506,
+        -0.0515,
+        -0.0524,
+        -0.0532,
+        -0.054,
+        -0.0547,
+        -0.0554,
+        -0.056,
+        -0.0565,
+        -0.057,
+        -0.0575,
+        -0.0579,
+        -0.0583,
+        -0.0586,
+        -0.0589,
+        -0.0592,
+        -0.0594,
+        -0.0595,
+        -0.0596,
+        -0.0597,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0597,
+        -0.0596,
+        -0.0594,
+        -0.0592,
+        -0.0589,
+        -0.0586,
+        -0.0582,
+        -0.0578,
+        -0.0573,
+        -0.0567,
+        -0.0561,
+        -0.0554,
+        -0.0546,
+        -0.0538,
+        -0.0529,
+        -0.0519,
+        -0.0509,
+        -0.0497,
+        -0.0485,
+        -0.0472,
+        -0.0458,
+        -0.0444,
+    ],
+    dtype="complex128",
+)
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        """
+        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
+        """
+
+        # Create a dictionary to store options about the surface
+        mesh_dict = {
+            "num_y": 7,
+            "num_x": 2,
+            "wing_type": "CRM",
+            "symmetry": True,
+            "num_twist_cp": 6,
+            "chord_cos_spacing": 0,
+            "span_cos_spacing": 0,
+        }
+
+        mesh, twist_cp = generate_mesh(mesh_dict)
+
+        surf_dict = {
+            # Wing definition
+            "name": "wing",  # name of the surface
+            "symmetry": True,  # if true, model one half of wing
+            # reflected across the plane y = 0
+            "S_ref_type": "wetted",  # how we compute the wing area,
+            # can be 'wetted' or 'projected'
+            "fem_model_type": "wingbox",
+            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+            "mesh": mesh,
+            "data_x_upper": upper_x,
+            "data_x_lower": lower_x,
+            "data_y_upper": upper_y,
+            "data_y_lower": lower_y,
+            # Aerodynamic performance of the lifting surface at
+            # an angle of attack of 0 (alpha=0).
+            # These CL0 and CD0 values are added to the CL and CD
+            # obtained from aerodynamic analysis of the surface to get
+            # the total CL and CD.
+            # These CL0 and CD0 values do not vary wrt alpha.
+            "CL0": 0.0,  # CL of the surface at alpha=0
+            "CD0": 0.0078,  # CD of the surface at alpha=0
+            # Airfoil properties for viscous drag calculation
+            "k_lam": 0.05,  # percentage of chord with laminar
+            # flow, used for viscous drag
+            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+            "original_wingbox_airfoil_t_over_c": 0.12,
+            "c_max_t": 0.38,  # chordwise location of maximum thickness
+            "with_viscous": True,
+            "with_wave": True,  # if true, compute wave drag
+            # Structural values are based on aluminum 7075
+            "E": 73.1e9,  # [Pa] Young's modulus
+            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
+            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "mrho": 2.78e3,  # [kg/m^3] material density
+            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
+            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
+            "wing_weight_ratio": 1.25,
+            "struct_weight_relief": True,
+            "distributed_fuel_weight": True,
+            # Constraints
+            "exact_failure_constraint": False,  # if false, use KS function
+            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+        }
+
+        surfaces = [surf_dict]
+
+        # Create the problem and assign the model group
+        prob = om.Problem()
+
+        # Add problem information as an independent variables component
+        indep_var_comp = om.IndepVarComp()
+        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
+        indep_var_comp.add_output("alpha", val=0.0, units="deg")
+        indep_var_comp.add_output("Mach_number", val=0.85)
+        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
+        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+        indep_var_comp.add_output("R", val=14.307e6, units="m")
+        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+        indep_var_comp.add_output("load_factor", val=np.array([1.0, 2.5]))
+        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+        indep_var_comp.add_output("fuel_mass", val=10000.0, units="kg")
+
+        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+        # Loop over each surface in the surfaces list
+        for surface in surfaces:
+            # Get the surface name and create a group to contain components
+            # only for this surface
+            name = surface["name"]
+
+            aerostruct_group = AerostructGeometry(surface=surface)
+
+            # Add tmp_group to the problem with the name of the surface.
+            prob.model.add_subsystem(name, aerostruct_group)
+
+        # Loop through and add a certain number of aero points
+        for i in range(2):
+            point_name = "AS_point_{}".format(i)
+            # Connect the parameters within the model for each aero point
+
+            # Create the aero point group and add it to the model
+            AS_point = AerostructPoint(surfaces=surfaces, internally_connect_fuelburn=False)
+
+            prob.model.add_subsystem(point_name, AS_point)
+
+            # Connect flow properties to the analysis point
+            prob.model.connect("v", point_name + ".v")
+            prob.model.connect("alpha", point_name + ".alpha")
+            prob.model.connect("Mach_number", point_name + ".Mach_number")
+            prob.model.connect("re", point_name + ".re")
+            prob.model.connect("rho", point_name + ".rho")
+            prob.model.connect("CT", point_name + ".CT")
+            prob.model.connect("R", point_name + ".R")
+            prob.model.connect("W0", point_name + ".W0")
+            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+            prob.model.connect("empty_cg", point_name + ".empty_cg")
+            prob.model.connect("load_factor", point_name + ".load_factor", src_indices=[i])
+            prob.model.connect("fuel_mass", point_name + ".total_perf.L_equals_W.fuelburn")
+            prob.model.connect("fuel_mass", point_name + ".total_perf.CG.fuelburn")
+
+            for _surface in surfaces:
+                prob.model.connect("load_factor", point_name + ".coupled.load_factor", src_indices=[i])
+
+                com_name = point_name + "." + name + "_perf."
+                prob.model.connect(
+                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+                )
+                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+                # Connect aerodyamic mesh to coupled group mesh
+                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+                # Connect performance calculation variables
+                prob.model.connect(name + ".nodes", com_name + "nodes")
+                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+                prob.model.connect(
+                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
+                )
+
+                # Connect wingbox properties to von Mises stress calcs
+                prob.model.connect(name + ".Qz", com_name + "Qz")
+                prob.model.connect(name + ".J", com_name + "J")
+                prob.model.connect(name + ".A_enc", com_name + "A_enc")
+                prob.model.connect(name + ".htop", com_name + "htop")
+                prob.model.connect(name + ".hbottom", com_name + "hbottom")
+                prob.model.connect(name + ".hfront", com_name + "hfront")
+                prob.model.connect(name + ".hrear", com_name + "hrear")
+
+                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+        # =======================================================================================
+        # Here we add the fuel volume constraint componenet to the model
+        # =======================================================================================
+        prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+        prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+
+        prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+        prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
+        prob.model.connect("fuel_mass", "AS_point_0.coupled.wing.struct_states.fuel_mass")
+
+        prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_1.coupled.wing.struct_states.fuel_vols")
+        prob.model.connect("fuel_mass", "AS_point_1.coupled.wing.struct_states.fuel_mass")
+
+        comp = om.ExecComp("fuel_diff = (fuel_mass - fuelburn) / fuelburn", units="kg")
+        prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
+        prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
+
+        comp = om.ExecComp("fuel_diff_25 = (fuel_mass - fuelburn) / fuelburn", units="kg")
+        prob.model.add_subsystem("fuel_diff_25", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff_25"])
+        prob.model.connect("AS_point_1.fuelburn", "fuel_diff_25.fuelburn")
+        # =======================================================================================
+        # =======================================================================================
+
+        prob.driver = om.ScipyOptimizeDriver()
+        prob.driver.options["tol"] = 1e-9
+        prob.driver.options["maxiter"] = 5
+
+        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+        prob.model.add_design_var("fuel_mass", lower=0.0, upper=2e5, scaler=1e-5)
+
+        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+        # =======================================================================================
+        # Here we add the fuel volume constraint
+        # =======================================================================================
+        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+        prob.model.add_constraint("fuel_diff", equals=0.0)
+        prob.model.add_constraint("fuel_diff_25", equals=0.0)
+        # =======================================================================================
+        # =======================================================================================
+
+        # Set up the problem
+        prob.setup()
+
+        # om.view_model(prob)
+
+        prob.run_model()
+
+        # Check the partials at the initial point in the design space,
+        # only care about relative error
+        # the list of components that uses CS to compute derivatives. We exclude them from check_partials
+        excludes_list = ["wing.wingbox_group.wingbox", "*.fuel_vol", "*.fuel_loads", "*.vonmises", "fuel_vol_delta"]
+        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
+        assert_check_partials(data, atol=1e20, rtol=1e-6)
+
+        # Run the optimizer for 5 iterations
+        prob.run_driver()
+
+        # Check the partials at this point in the design space
+        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
+        assert_check_partials(data, atol=1e20, rtol=1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_wingbox_analysis.py b/tests/integration_tests/test_wingbox_analysis.py
index 44842a850..07c9172f3 100644
--- a/tests/integration_tests/test_wingbox_analysis.py
+++ b/tests/integration_tests/test_wingbox_analysis.py
@@ -254,7 +254,6 @@ def test(self):
             "data_x_lower": lower_x,
             "data_y_upper": upper_y,
             "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
             # Aerodynamic performance of the lifting surface at
             # an angle of attack of 0 (alpha=0).
             # These CL0 and CD0 values are added to the CL and CD
diff --git a/tests/integration_tests/test_wingbox_derivs.py b/tests/integration_tests/test_wingbox_derivs.py
index daaca33ac..71a5b09dd 100644
--- a/tests/integration_tests/test_wingbox_derivs.py
+++ b/tests/integration_tests/test_wingbox_derivs.py
@@ -1,461 +1,460 @@
-import unittest
-import numpy as np
-
-from openaerostruct.meshing.mesh_generator import generate_mesh
-
-from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
-
-import openmdao.api as om
-from openmdao.utils.assert_utils import assert_check_partials
-from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
-
-
-# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
-# These should be for an airfoil with the chord scaled to 1.
-# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
-# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
-# The first and last x-coordinates of the upper and lower skins must be the same
-
-upper_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ]
-)
-lower_x = np.array(
-    [
-        0.1,
-        0.11,
-        0.12,
-        0.13,
-        0.14,
-        0.15,
-        0.16,
-        0.17,
-        0.18,
-        0.19,
-        0.2,
-        0.21,
-        0.22,
-        0.23,
-        0.24,
-        0.25,
-        0.26,
-        0.27,
-        0.28,
-        0.29,
-        0.3,
-        0.31,
-        0.32,
-        0.33,
-        0.34,
-        0.35,
-        0.36,
-        0.37,
-        0.38,
-        0.39,
-        0.4,
-        0.41,
-        0.42,
-        0.43,
-        0.44,
-        0.45,
-        0.46,
-        0.47,
-        0.48,
-        0.49,
-        0.5,
-        0.51,
-        0.52,
-        0.53,
-        0.54,
-        0.55,
-        0.56,
-        0.57,
-        0.58,
-        0.59,
-        0.6,
-    ]
-)
-upper_y = np.array(
-    [
-        0.0447,
-        0.046,
-        0.0472,
-        0.0484,
-        0.0495,
-        0.0505,
-        0.0514,
-        0.0523,
-        0.0531,
-        0.0538,
-        0.0545,
-        0.0551,
-        0.0557,
-        0.0563,
-        0.0568,
-        0.0573,
-        0.0577,
-        0.0581,
-        0.0585,
-        0.0588,
-        0.0591,
-        0.0593,
-        0.0595,
-        0.0597,
-        0.0599,
-        0.06,
-        0.0601,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0602,
-        0.0601,
-        0.06,
-        0.0599,
-        0.0598,
-        0.0596,
-        0.0594,
-        0.0592,
-        0.0589,
-        0.0586,
-        0.0583,
-        0.058,
-        0.0576,
-        0.0572,
-        0.0568,
-        0.0563,
-        0.0558,
-        0.0553,
-        0.0547,
-        0.0541,
-    ]
-)
-lower_y = np.array(
-    [
-        -0.0447,
-        -0.046,
-        -0.0473,
-        -0.0485,
-        -0.0496,
-        -0.0506,
-        -0.0515,
-        -0.0524,
-        -0.0532,
-        -0.054,
-        -0.0547,
-        -0.0554,
-        -0.056,
-        -0.0565,
-        -0.057,
-        -0.0575,
-        -0.0579,
-        -0.0583,
-        -0.0586,
-        -0.0589,
-        -0.0592,
-        -0.0594,
-        -0.0595,
-        -0.0596,
-        -0.0597,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0598,
-        -0.0597,
-        -0.0596,
-        -0.0594,
-        -0.0592,
-        -0.0589,
-        -0.0586,
-        -0.0582,
-        -0.0578,
-        -0.0573,
-        -0.0567,
-        -0.0561,
-        -0.0554,
-        -0.0546,
-        -0.0538,
-        -0.0529,
-        -0.0519,
-        -0.0509,
-        -0.0497,
-        -0.0485,
-        -0.0472,
-        -0.0458,
-        -0.0444,
-    ]
-)
-
-
-class Test(unittest.TestCase):
-    def test(self):
-        """
-        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
-        """
-
-        # Create a dictionary to store options about the surface
-        mesh_dict = {
-            "num_y": 7,
-            "num_x": 2,
-            "wing_type": "CRM",
-            "symmetry": True,
-            "num_twist_cp": 6,
-            "chord_cos_spacing": 0,
-            "span_cos_spacing": 0,
-        }
-
-        mesh, twist_cp = generate_mesh(mesh_dict)
-
-        surf_dict = {
-            # Wing definition
-            "name": "wing",  # name of the surface
-            "symmetry": True,  # if true, model one half of wing
-            # reflected across the plane y = 0
-            "S_ref_type": "wetted",  # how we compute the wing area,
-            # can be 'wetted' or 'projected'
-            "fem_model_type": "wingbox",
-            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
-            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
-            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
-            "mesh": mesh,
-            "data_x_upper": upper_x,
-            "data_x_lower": lower_x,
-            "data_y_upper": upper_y,
-            "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
-            # Aerodynamic performance of the lifting surface at
-            # an angle of attack of 0 (alpha=0).
-            # These CL0 and CD0 values are added to the CL and CD
-            # obtained from aerodynamic analysis of the surface to get
-            # the total CL and CD.
-            # These CL0 and CD0 values do not vary wrt alpha.
-            "CL0": 0.0,  # CL of the surface at alpha=0
-            "CD0": 0.0078,  # CD of the surface at alpha=0
-            # Airfoil properties for viscous drag calculation
-            "k_lam": 0.05,  # percentage of chord with laminar
-            # flow, used for viscous drag
-            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
-            "original_wingbox_airfoil_t_over_c": 0.12,
-            "c_max_t": 0.38,  # chordwise location of maximum thickness
-            "with_viscous": True,
-            "with_wave": True,  # if true, compute wave drag
-            # Structural values are based on aluminum 7075
-            "E": 73.1e9,  # [Pa] Young's modulus
-            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
-            "mrho": 2.78e3,  # [kg/m^3] material density
-            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
-            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
-            "wing_weight_ratio": 1.25,
-            "struct_weight_relief": True,
-            "distributed_fuel_weight": True,
-            # Constraints
-            "exact_failure_constraint": False,  # if false, use KS function
-            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
-            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
-        }
-
-        surfaces = [surf_dict]
-
-        # Create the problem and assign the model group
-        prob = om.Problem()
-
-        # Add problem information as an independent variables component
-        indep_var_comp = om.IndepVarComp()
-        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
-        indep_var_comp.add_output("alpha", val=0.0, units="deg")
-        indep_var_comp.add_output("Mach_number", val=0.85)
-        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
-        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
-        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
-        indep_var_comp.add_output("R", val=14.307e6, units="m")
-        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
-        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
-        indep_var_comp.add_output("load_factor", val=1.0)
-        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
-        indep_var_comp.add_output("fuel_mass", val=10000.0, units="kg")
-
-        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
-
-        # Loop over each surface in the surfaces list
-        for surface in surfaces:
-            # Get the surface name and create a group to contain components
-            # only for this surface
-            name = surface["name"]
-
-            aerostruct_group = AerostructGeometry(surface=surface)
-
-            # Add tmp_group to the problem with the name of the surface.
-            prob.model.add_subsystem(name, aerostruct_group)
-
-        # Loop through and add a certain number of aero points
-        for i in range(1):
-            point_name = "AS_point_{}".format(i)
-            # Connect the parameters within the model for each aero point
-
-            # Create the aero point group and add it to the model
-            AS_point = AerostructPoint(surfaces=surfaces)
-
-            prob.model.add_subsystem(point_name, AS_point)
-
-            # Connect flow properties to the analysis point
-            prob.model.connect("v", point_name + ".v")
-            prob.model.connect("alpha", point_name + ".alpha")
-            prob.model.connect("Mach_number", point_name + ".Mach_number")
-            prob.model.connect("re", point_name + ".re")
-            prob.model.connect("rho", point_name + ".rho")
-            prob.model.connect("CT", point_name + ".CT")
-            prob.model.connect("R", point_name + ".R")
-            prob.model.connect("W0", point_name + ".W0")
-            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
-            prob.model.connect("empty_cg", point_name + ".empty_cg")
-            prob.model.connect("load_factor", point_name + ".load_factor")
-
-            for _surface in surfaces:
-                prob.model.connect("load_factor", point_name + ".coupled.load_factor")
-
-                com_name = point_name + "." + name + "_perf."
-                prob.model.connect(
-                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
-                )
-                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
-
-                # Connect aerodyamic mesh to coupled group mesh
-                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
-                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
-
-                # Connect performance calculation variables
-                prob.model.connect(name + ".nodes", com_name + "nodes")
-                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
-                prob.model.connect(
-                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
-                )
-
-                # Connect wingbox properties to von Mises stress calcs
-                prob.model.connect(name + ".Qz", com_name + "Qz")
-                prob.model.connect(name + ".J", com_name + "J")
-                prob.model.connect(name + ".A_enc", com_name + "A_enc")
-                prob.model.connect(name + ".htop", com_name + "htop")
-                prob.model.connect(name + ".hbottom", com_name + "hbottom")
-                prob.model.connect(name + ".hfront", com_name + "hfront")
-                prob.model.connect(name + ".hrear", com_name + "hrear")
-
-                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
-                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
-
-            # =======================================================================================
-            # Here we add the fuel volume constraint componenet to the model
-            # =======================================================================================
-            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
-            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
-            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
-            prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
-            prob.model.connect("fuel_mass", "AS_point_0.coupled.wing.struct_states.fuel_mass")
-
-            comp = om.ExecComp(
-                "fuel_diff = (fuel_mass - fuelburn) / fuelburn",
-                fuel_mass={"val": 1.0, "units": "kg"},
-                fuelburn={"val": 1.0, "units": "kg"},
-            )
-            prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
-            prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
-            # =======================================================================================
-            # =======================================================================================
-
-        prob.driver = om.ScipyOptimizeDriver()
-        prob.driver.options["tol"] = 1e-9
-        prob.driver.options["maxiter"] = 2
-
-        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
-
-        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
-        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
-        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
-        prob.model.add_design_var("fuel_mass", lower=0.0, upper=2e5, scaler=1e-5)
-
-        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
-        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
-
-        # =======================================================================================
-        # Here we add the fuel volume constraint
-        # =======================================================================================
-        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
-        prob.model.add_constraint("fuel_diff", equals=0.0)
-        # =======================================================================================
-        # =======================================================================================
-
-        # Set up the problem
-        prob.setup()
-
-        prob.run_model()
-
-        # Check the partials at the initial point in the design space,
-        # only care about relative error
-        # the list of components that uses CS to compute derivatives. We exclude them from check_partials
-        excludes_list = ["wing.wingbox_group.wingbox", "*.fuel_vol", "*.fuel_loads", "*.vonmises", "fuel_vol_delta"]
-        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
-
-        assert_check_partials(data, atol=1e20, rtol=1e-6)
-
-        # Run the optimizer for 2 iterations
-        prob.run_driver()
-
-        # Check the partials at this point in the design space
-        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
-        assert_check_partials(data, atol=1e20, rtol=1e-6)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+import numpy as np
+
+from openaerostruct.meshing.mesh_generator import generate_mesh
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+import openmdao.api as om
+from openmdao.utils.assert_utils import assert_check_partials
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+upper_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ]
+)
+lower_x = np.array(
+    [
+        0.1,
+        0.11,
+        0.12,
+        0.13,
+        0.14,
+        0.15,
+        0.16,
+        0.17,
+        0.18,
+        0.19,
+        0.2,
+        0.21,
+        0.22,
+        0.23,
+        0.24,
+        0.25,
+        0.26,
+        0.27,
+        0.28,
+        0.29,
+        0.3,
+        0.31,
+        0.32,
+        0.33,
+        0.34,
+        0.35,
+        0.36,
+        0.37,
+        0.38,
+        0.39,
+        0.4,
+        0.41,
+        0.42,
+        0.43,
+        0.44,
+        0.45,
+        0.46,
+        0.47,
+        0.48,
+        0.49,
+        0.5,
+        0.51,
+        0.52,
+        0.53,
+        0.54,
+        0.55,
+        0.56,
+        0.57,
+        0.58,
+        0.59,
+        0.6,
+    ]
+)
+upper_y = np.array(
+    [
+        0.0447,
+        0.046,
+        0.0472,
+        0.0484,
+        0.0495,
+        0.0505,
+        0.0514,
+        0.0523,
+        0.0531,
+        0.0538,
+        0.0545,
+        0.0551,
+        0.0557,
+        0.0563,
+        0.0568,
+        0.0573,
+        0.0577,
+        0.0581,
+        0.0585,
+        0.0588,
+        0.0591,
+        0.0593,
+        0.0595,
+        0.0597,
+        0.0599,
+        0.06,
+        0.0601,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0602,
+        0.0601,
+        0.06,
+        0.0599,
+        0.0598,
+        0.0596,
+        0.0594,
+        0.0592,
+        0.0589,
+        0.0586,
+        0.0583,
+        0.058,
+        0.0576,
+        0.0572,
+        0.0568,
+        0.0563,
+        0.0558,
+        0.0553,
+        0.0547,
+        0.0541,
+    ]
+)
+lower_y = np.array(
+    [
+        -0.0447,
+        -0.046,
+        -0.0473,
+        -0.0485,
+        -0.0496,
+        -0.0506,
+        -0.0515,
+        -0.0524,
+        -0.0532,
+        -0.054,
+        -0.0547,
+        -0.0554,
+        -0.056,
+        -0.0565,
+        -0.057,
+        -0.0575,
+        -0.0579,
+        -0.0583,
+        -0.0586,
+        -0.0589,
+        -0.0592,
+        -0.0594,
+        -0.0595,
+        -0.0596,
+        -0.0597,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0598,
+        -0.0597,
+        -0.0596,
+        -0.0594,
+        -0.0592,
+        -0.0589,
+        -0.0586,
+        -0.0582,
+        -0.0578,
+        -0.0573,
+        -0.0567,
+        -0.0561,
+        -0.0554,
+        -0.0546,
+        -0.0538,
+        -0.0529,
+        -0.0519,
+        -0.0509,
+        -0.0497,
+        -0.0485,
+        -0.0472,
+        -0.0458,
+        -0.0444,
+    ]
+)
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        """
+        This is an opt problem that tests the wingbox model with wave drag and the fuel vol constraint
+        """
+
+        # Create a dictionary to store options about the surface
+        mesh_dict = {
+            "num_y": 7,
+            "num_x": 2,
+            "wing_type": "CRM",
+            "symmetry": True,
+            "num_twist_cp": 6,
+            "chord_cos_spacing": 0,
+            "span_cos_spacing": 0,
+        }
+
+        mesh, twist_cp = generate_mesh(mesh_dict)
+
+        surf_dict = {
+            # Wing definition
+            "name": "wing",  # name of the surface
+            "symmetry": True,  # if true, model one half of wing
+            # reflected across the plane y = 0
+            "S_ref_type": "wetted",  # how we compute the wing area,
+            # can be 'wetted' or 'projected'
+            "fem_model_type": "wingbox",
+            "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+            "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+            "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+            "mesh": mesh,
+            "data_x_upper": upper_x,
+            "data_x_lower": lower_x,
+            "data_y_upper": upper_y,
+            "data_y_lower": lower_y,
+            # Aerodynamic performance of the lifting surface at
+            # an angle of attack of 0 (alpha=0).
+            # These CL0 and CD0 values are added to the CL and CD
+            # obtained from aerodynamic analysis of the surface to get
+            # the total CL and CD.
+            # These CL0 and CD0 values do not vary wrt alpha.
+            "CL0": 0.0,  # CL of the surface at alpha=0
+            "CD0": 0.0078,  # CD of the surface at alpha=0
+            # Airfoil properties for viscous drag calculation
+            "k_lam": 0.05,  # percentage of chord with laminar
+            # flow, used for viscous drag
+            "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+            "original_wingbox_airfoil_t_over_c": 0.12,
+            "c_max_t": 0.38,  # chordwise location of maximum thickness
+            "with_viscous": True,
+            "with_wave": True,  # if true, compute wave drag
+            # Structural values are based on aluminum 7075
+            "E": 73.1e9,  # [Pa] Young's modulus
+            "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
+            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "mrho": 2.78e3,  # [kg/m^3] material density
+            "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
+            # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
+            "wing_weight_ratio": 1.25,
+            "struct_weight_relief": True,
+            "distributed_fuel_weight": True,
+            # Constraints
+            "exact_failure_constraint": False,  # if false, use KS function
+            "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+            "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+        }
+
+        surfaces = [surf_dict]
+
+        # Create the problem and assign the model group
+        prob = om.Problem()
+
+        # Add problem information as an independent variables component
+        indep_var_comp = om.IndepVarComp()
+        indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
+        indep_var_comp.add_output("alpha", val=0.0, units="deg")
+        indep_var_comp.add_output("Mach_number", val=0.85)
+        indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
+        indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+        indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+        indep_var_comp.add_output("R", val=14.307e6, units="m")
+        indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+        indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+        indep_var_comp.add_output("load_factor", val=1.0)
+        indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+        indep_var_comp.add_output("fuel_mass", val=10000.0, units="kg")
+
+        prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+        # Loop over each surface in the surfaces list
+        for surface in surfaces:
+            # Get the surface name and create a group to contain components
+            # only for this surface
+            name = surface["name"]
+
+            aerostruct_group = AerostructGeometry(surface=surface)
+
+            # Add tmp_group to the problem with the name of the surface.
+            prob.model.add_subsystem(name, aerostruct_group)
+
+        # Loop through and add a certain number of aero points
+        for i in range(1):
+            point_name = "AS_point_{}".format(i)
+            # Connect the parameters within the model for each aero point
+
+            # Create the aero point group and add it to the model
+            AS_point = AerostructPoint(surfaces=surfaces)
+
+            prob.model.add_subsystem(point_name, AS_point)
+
+            # Connect flow properties to the analysis point
+            prob.model.connect("v", point_name + ".v")
+            prob.model.connect("alpha", point_name + ".alpha")
+            prob.model.connect("Mach_number", point_name + ".Mach_number")
+            prob.model.connect("re", point_name + ".re")
+            prob.model.connect("rho", point_name + ".rho")
+            prob.model.connect("CT", point_name + ".CT")
+            prob.model.connect("R", point_name + ".R")
+            prob.model.connect("W0", point_name + ".W0")
+            prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+            prob.model.connect("empty_cg", point_name + ".empty_cg")
+            prob.model.connect("load_factor", point_name + ".load_factor")
+
+            for _surface in surfaces:
+                prob.model.connect("load_factor", point_name + ".coupled.load_factor")
+
+                com_name = point_name + "." + name + "_perf."
+                prob.model.connect(
+                    name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+                )
+                prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+                # Connect aerodyamic mesh to coupled group mesh
+                prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+                prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+                # Connect performance calculation variables
+                prob.model.connect(name + ".nodes", com_name + "nodes")
+                prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+                prob.model.connect(
+                    name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass"
+                )
+
+                # Connect wingbox properties to von Mises stress calcs
+                prob.model.connect(name + ".Qz", com_name + "Qz")
+                prob.model.connect(name + ".J", com_name + "J")
+                prob.model.connect(name + ".A_enc", com_name + "A_enc")
+                prob.model.connect(name + ".htop", com_name + "htop")
+                prob.model.connect(name + ".hbottom", com_name + "hbottom")
+                prob.model.connect(name + ".hfront", com_name + "hfront")
+                prob.model.connect(name + ".hrear", com_name + "hrear")
+
+                prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+                prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+            # =======================================================================================
+            # Here we add the fuel volume constraint componenet to the model
+            # =======================================================================================
+            prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+            prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+            prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+            prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
+            prob.model.connect("fuel_mass", "AS_point_0.coupled.wing.struct_states.fuel_mass")
+
+            comp = om.ExecComp(
+                "fuel_diff = (fuel_mass - fuelburn) / fuelburn",
+                fuel_mass={"val": 1.0, "units": "kg"},
+                fuelburn={"val": 1.0, "units": "kg"},
+            )
+            prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
+            prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
+            # =======================================================================================
+            # =======================================================================================
+
+        prob.driver = om.ScipyOptimizeDriver()
+        prob.driver.options["tol"] = 1e-9
+        prob.driver.options["maxiter"] = 2
+
+        prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+        prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+        prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+        prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+        prob.model.add_design_var("fuel_mass", lower=0.0, upper=2e5, scaler=1e-5)
+
+        prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+        prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+        # =======================================================================================
+        # Here we add the fuel volume constraint
+        # =======================================================================================
+        prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+        prob.model.add_constraint("fuel_diff", equals=0.0)
+        # =======================================================================================
+        # =======================================================================================
+
+        # Set up the problem
+        prob.setup()
+
+        prob.run_model()
+
+        # Check the partials at the initial point in the design space,
+        # only care about relative error
+        # the list of components that uses CS to compute derivatives. We exclude them from check_partials
+        excludes_list = ["wing.wingbox_group.wingbox", "*.fuel_vol", "*.fuel_loads", "*.vonmises", "fuel_vol_delta"]
+        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
+
+        assert_check_partials(data, atol=1e20, rtol=1e-6)
+
+        # Run the optimizer for 2 iterations
+        prob.run_driver()
+
+        # Check the partials at this point in the design space
+        data = prob.check_partials(compact_print=True, out_stream=None, excludes=excludes_list, method="cs", step=1e-40)
+        assert_check_partials(data, atol=1e20, rtol=1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_wingbox_distributed_fuel.py b/tests/integration_tests/test_wingbox_distributed_fuel.py
index 95ea3baab..c29034b7b 100644
--- a/tests/integration_tests/test_wingbox_distributed_fuel.py
+++ b/tests/integration_tests/test_wingbox_distributed_fuel.py
@@ -277,7 +277,6 @@ def test(self):
             "data_x_lower": lower_x,
             "data_y_upper": upper_y,
             "data_y_lower": lower_y,
-            "strength_factor_for_upper_skin": 1.0,
             # Aerodynamic performance of the lifting surface at
             # an angle of attack of 0 (alpha=0).
             # These CL0 and CD0 values are added to the CL and CD

From ceb7c907ffafb798de786a7e03c66c086824f812 Mon Sep 17 00:00:00 2001
From: Vishwa Mehta <87753423+vishhwamehta@users.noreply.github.com>
Date: Mon, 29 Sep 2025 11:33:22 -0400
Subject: [PATCH 22/30] Composite material model and Tsai-Wu failure criterion;
 introduce safety_factor (#444)

* initial commit for tsaiwu wingbox package

* Make geometry spline interpolation mesh independent

* formatting changes

* implemented "useComposite" in the surfdict for the option of using composite materials and made changes to all the relevant scripts along with the calculation of effective stiffness values for composite materials

* changed the surface dictionary in the test files to work with the new keys

* Made the changes with if statements of "useComposite", bug fixes with numofplies and num_failure_criteria, added raise commands for surf dict

* cleaning all the codes, removing unnecessary comments and updating the group descriptions for the failure groups and tsaiwuwingbox

* bug fixes due to the hardcoded 4 plies

* Modify surface dictionary checks

* Rename surface dict variables to follow OAS conventions

* Undo artifact from previous merge

* Fix error message

* correcting the spatial_beam_functionals

* `black -l 120 .`

* `black -l 120 .`

* Fix docstring in failure_ks

* fixing the files flagged for pull request tests

* removing the call for shwoing n2, and fixing formatting bug

* removing the asert.near.equal import statement from test file

* failure files and check_surface_dict modified to use "safety_factor". All test files using yield/SF modified to have a safety_factor key

* removed unused import statements, adding option for the cases where safety factor is absent

* creating and editing the documentation files for OAS documentation

* updating heirarchy for the documentation files

* Add code excerpt to composites doc page

* documemtation for composite wingbox

* updated the documentation page

* changed the safety factor documentation and added the Pareto front to the walkthrough page

* Simplifying some code in failure_ks

* small docs fix

* variable renaming

* More robust if check

* Check against lower case strings

* move functions to structure.utils

* remove unused var

* update integration tests

* rename test file

* moved effective E and G computation to runscript level to be more general

* documentation update

* moved example script from docs folder to example folder

* updated example script

* fixed stiffness matrix transformation and added unit test

* fixed strain transformation in tsai-wu comp and refactoring

* working on Gray2024 benchmark model

* updated benchmark example

* ruff

* docs minor update

* docs update

* docs minor fixes

* update tsaiwu test

* format

* typos in docs

* fixed safety_factor and removed debugging leftovers

* Alter composite transformations

---------

Co-authored-by: Alasdair Gray <alachris@umich.edu>
Co-authored-by: kanekosh <shugok@umich.edu>
---
 openaerostruct/docs/advanced_features.rst     |   1 +
 .../composites_walkthrough.rst                | 196 ++++++++
 .../scripts/two_part_wing_custom_mesh.py      |   3 +-
 .../scripts/wingbox_mpt_Q400_example.py       |   3 +-
 .../aerostructural_wingbox_walkthrough.rst    |   6 +-
 .../docs/user_reference/mesh_surface_dict.rst |   8 +-
 .../docs/wingbox_mpt_opt_example.py           |   3 +-
 openaerostruct/examples/black_box_example.py  |   3 +-
 openaerostruct/examples/run_CRM.py            |   3 +-
 ...run_aerostruct_composite_benchmark_wing.py | 424 ++++++++++++++++++
 .../run_aerostruct_uCRM_composite_wingbox.py  | 300 +++++++++++++
 .../run_aerostruct_uCRM_multipoint.py         |   3 +-
 openaerostruct/examples/run_scaneagle.py      |   1 +
 .../integration/aerostruct_groups.py          |  34 +-
 openaerostruct/structures/compute_nodes.py    |   2 +-
 openaerostruct/structures/failure_exact.py    |  53 ++-
 openaerostruct/structures/failure_ks.py       |  78 ++--
 .../structures/spatial_beam_functionals.py    |  77 +++-
 .../structures/spatial_beam_setup.py          |   2 +-
 openaerostruct/structures/struct_groups.py    |  37 +-
 openaerostruct/structures/tsaiwu_wingbox.py   | 235 ++++++++++
 openaerostruct/structures/utils.py            | 107 +++++
 openaerostruct/transfer/load_transfer.py      |   2 +-
 openaerostruct/utils/check_surface_dict.py    |  51 +++
 openaerostruct/utils/plot_wingbox.py          |   1 -
 openaerostruct/utils/testing.py               |   6 +-
 tests/integration_tests/test_aerostruct.py    |   3 +-
 .../test_aerostruct_analysis.py               |   3 +-
 .../test_aerostruct_analysis_Sref.py          |   3 +-
 .../test_aerostruct_analysis_compressible.py  |   3 +-
 .../test_aerostruct_engine_thrusts.py         |   3 +-
 .../integration_tests/test_aerostruct_ffd.py  |   3 +-
 .../test_aerostruct_groundeffect.py           |   3 +-
 .../test_aerostruct_point_loads.py            |   3 +-
 .../test_aerostruct_tsaiwuwingbox.py          | 227 ++++++++++
 ...est_aerostruct_wingbox_+weight_analysis.py |   3 +-
 .../test_aerostruct_wingbox_analysis.py       |   3 +-
 ...ostruct_wingbox_fuel_vol_constraint_opt.py |   3 +-
 .../test_aerostruct_wingbox_opt.py            |   3 +-
 ...ct_wingbox_wave_fuel_vol_constraint_opt.py |   3 +-
 .../test_morphing_aerostruct.py               |   3 +-
 .../test_multipoint_parallel.py               |   3 +-
 .../test_multipoint_wingbox_aerostruct.py     |   3 +-
 .../test_multipoint_wingbox_derivs.py         |   3 +-
 tests/integration_tests/test_scaneagle.py     |   1 +
 .../integration_tests/test_simple_rect_AS.py  |   3 +-
 tests/integration_tests/test_struct.py        |   3 +-
 .../integration_tests/test_struct_analysis.py |   3 +-
 .../test_struct_analysis_2g.py                |   3 +-
 .../test_struct_engine_thrusts.py             |   6 +-
 .../integration_tests/test_struct_no_loads.py |   3 +-
 .../test_struct_point_masses.py               |   6 +-
 .../test_v1_aerostruct_analysis.py            |   3 +-
 .../test_v1_aerostruct_opt.py                 |   3 +-
 .../test_v1_struct_analysis.py                |   3 +-
 tests/integration_tests/test_v1_struct_opt.py |   3 +-
 .../test_wingbox_analysis.py                  |   3 +-
 .../integration_tests/test_wingbox_derivs.py  |   3 +-
 .../test_wingbox_distributed_fuel.py          |   3 +-
 .../test_composite_equivalent_stiffness.py    |  56 +++
 60 files changed, 1893 insertions(+), 129 deletions(-)
 create mode 100644 openaerostruct/docs/advanced_features/composites_walkthrough.rst
 create mode 100644 openaerostruct/examples/run_aerostruct_composite_benchmark_wing.py
 create mode 100644 openaerostruct/examples/run_aerostruct_uCRM_composite_wingbox.py
 create mode 100644 openaerostruct/structures/tsaiwu_wingbox.py
 create mode 100644 tests/integration_tests/test_aerostruct_tsaiwuwingbox.py
 create mode 100644 tests/structures_tests/test_composite_equivalent_stiffness.py

diff --git a/openaerostruct/docs/advanced_features.rst b/openaerostruct/docs/advanced_features.rst
index 4037f6b30..5d46de47e 100644
--- a/openaerostruct/docs/advanced_features.rst
+++ b/openaerostruct/docs/advanced_features.rst
@@ -22,3 +22,4 @@ These examples show some advanced features in OpenAeroStruct.
    advanced_features/customizing_prob_setup.rst
    advanced_features/mphys_coupling.rst
    advanced_features/stability_derivatives.rst
+   advanced_features/composites_walkthrough.rst
diff --git a/openaerostruct/docs/advanced_features/composites_walkthrough.rst b/openaerostruct/docs/advanced_features/composites_walkthrough.rst
new file mode 100644
index 000000000..a54341345
--- /dev/null
+++ b/openaerostruct/docs/advanced_features/composites_walkthrough.rst
@@ -0,0 +1,196 @@
+.. _Composites Walkthrough:
+
+Composite Material
+==================
+
+This page will walk you through the composites model in OpenAeroStruct.
+The composites module allows you to define composite material properties and laminate layups for the wing structure.
+
+Model setup
+-----------
+
+First, define the following parameters in the `surface` dictionary:
+
+- ``useComposite`` is a boolean variable that is set to True to enable the composites model mode.
+- ``safety_factor`` is the factor of safety used for determining the Tsai-Wu based failure
+- ``ply_angles`` is a list of the angles of the plies with respect to the x-axis.
+- ``ply_fractions`` is a list of the ply fractions of the plies. (Should be the same length as ``ply_angles``, with the sum of the fractions equal to 1).
+- ``E1`` is the modulus of elasticity in the fiber direction.
+- ``E2`` is the modulus of elasticity in the transverse direction.
+- ``G12`` is the shear modulus.
+- ``nu12`` is the Poisson's ratio.
+- ``sigma_t1`` is the tensile strength in the fiber direction.
+- ``sigma_c1`` is the compressive strength in the fiber direction.
+- ``sigma_t2`` is the tensile strength in the transverse direction.
+- ``sigma_c2`` is the compressive strength in the transverse direction.
+- ``sigma_12max`` is the maximum shear strength.
+
+.. note::
+    The composites failure model doesn't use the ``strength_factor_for_upper_skin`` option from the surface dictionary.
+    If you want to apply a knockdown factor on the compressive strength to account for buckling, you should scale down the values of ``sigma_c1`` and ``sigma_c2``.
+
+Next, call a utility function to compute the effective E and G for the composite material.
+The following function adds ``E`` and ``G`` to ``surface``.
+
+.. code-block:: python
+
+    from openaerostruct.structures.utils import compute_composite_stiffness
+    compute_composite_stiffness(surf_dict)
+
+The rest of the model setup is the same as aluminum wing aerostructural problems.
+OpenAeroStruct will compute the failure metric based on the Tsai-Wu failure criterion instead of the von Mises failure criterion when we set ``useComposite`` to True.
+But this is done automatically within ``AerostructPoint``, so you don't need to do anything about it.
+
+Theory
+------
+
+Approximation of the Moduli of Elasticity
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Currently, the moduli of elasticity of the entire FEM spatial beam model are assumed to be isotropic
+in 2D plane so as to not change the entire model and is left for the future works.
+The values of the moduli of elasticity are found using the following procedure.
+
+The unidirectional ply properties are used to find the stiffness matrix of the plies:
+
+.. math::
+
+    Q = \begin{bmatrix}
+    \frac{E_1}{1-\nu_{12}\nu_{21}} & \frac{\nu_{21}E_2}{1-\nu_{12}\nu_{21}} & 0 \\
+    \frac{\nu_{12}E_1}{1-\nu_{12}\nu_{21}} & \frac{E_2}{1-\nu_{12}\nu_{21}} & 0 \\
+    0 & 0 & G_{12}
+    \end{bmatrix}
+
+where :math:`E_1` and :math:`E_2` are the moduli of elasticity in the fiber direction and transverse direction, respectively,
+:math:`\nu_{12}` and :math:`\nu_{21}` are the Poisson's ratios, and :math:`G_{12}` is the shear modulus.
+
+We then transform the stiffness matrix of each ply as a function of the ply angle by
+
+.. math::
+
+    \bar{Q} = T_\sigma Q T_\varepsilon^{-1}
+
+where :math:`T_\sigma`, :math:`T_\varepsilon` are the stress and strain transformation matrices, respectively.
+
+The effective stiffness matrix for the laminate is found using the weighted sum of the stiffness matrices of the plies,
+using their respective ply fraction:
+
+.. math::
+
+    Q_{eff} = \sum_{i=1}^{n} f_i \bar{Q}_i
+
+where :math:`f_i` is the ply fraction of the :math:`i^{th}` ply.
+
+The effective compliance matrix is found using the following equation:
+
+.. math::
+
+    S_{eff} = Q_{eff}^{-1}
+
+The effective laminate properties are found using the following equations:
+
+.. math::
+    E = \frac{1}{S_{eff_{11}}}\\
+    G = \frac{1}{S_{eff_{66}}}
+
+These moduli of elasticity values are hence used to determine the stiffness matrix of the entire FEM spatial beam model.
+
+Tsai-Wu Failure Criterion
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Thereafter, at the 4 critical points in the wingbox (mentioned in the aerostruct-wingbox walkthrough),
+the strains are calculated for each of the constituent plies by transforming the strains at the critical points to the laminate coordinate system. This is done using the following equation:
+
+.. math::
+
+    \begin{pmatrix}
+    \epsilon_1 \\
+    \epsilon_2 \\
+    \gamma_{12}
+    \end{pmatrix}
+    =
+    [T_\varepsilon]
+    \begin{pmatrix}
+    \epsilon_x \\
+    \epsilon_y \\
+    \gamma_{xy}
+    \end{pmatrix}
+
+The strains are then used to calculate the stresses in the laminate using the following equation:
+
+.. math::
+
+    \begin{pmatrix}
+    \sigma_1 \\
+    \sigma_2 \\
+    \tau_{12}
+    \end{pmatrix}
+    =
+    [Q]
+    \begin{pmatrix}
+    \epsilon_1 \\
+    \epsilon_2 \\
+    \gamma_{12}
+    \end{pmatrix}
+
+These local axial and shear stresses are then utilized to calculate the value of the **Strength Ratios**, where the coefficients are defined by:
+
+.. math::
+
+    F_{11} = \frac{1}{S_L^{(+)} S_L^{(-)}} \quad \text{and} \quad F_1 = \frac{1}{S_L^{(+)}} - \frac{1}{S_L^{(-)}}
+
+.. math::
+
+    F_{22} = \frac{1}{S_T^{(+)} S_T^{(-)}} \quad \text{and} \quad F_2 = \frac{1}{S_T^{(+)}} - \frac{1}{S_T^{(-)}}
+
+.. math::
+
+    F_{66} = \frac{1}{2 S_{LT}^{2}}
+
+where :math:`S_L^{(+)} \text{and} S_L^{(-)}` are the longitudinal strengths in tension and compression respectively,
+:math:`S_T^{(+)} \text{and} S_T^{(-)}` are the transverse strengths in tension and compression respectively and
+:math:`S_{LT}^{(+)}` is the shear strength of a ply. The strength ratios are then used to calculate the Tsai-Wu based failure criterion for each ply.
+The Tsai-Wu failure criterion is given by:
+
+.. math::
+
+    F_1 \sigma_1 + F_2 \sigma_2 + F_{11} \sigma_1^2 + F_{22} \sigma_2^2 + F_{66} \tau_{12}^2 = 1
+
+In order to implement the safety factor in the Tsai-Wu failure criterion, the equation is re-written as:
+
+.. math::
+    a &= F_1 \sigma_1 + F_2 \sigma_2 \\
+    b &= F_{11} \sigma_1^2 + F_{22} \sigma_2^2 + F_{12} \sigma_1 \sigma_2
+
+We hence calculate the **Strength Ratios** using the formula:
+
+.. math::
+
+    SR = \frac{1}{2} (a + \sqrt{a^2 + 4 b})
+
+The strength ratio values hence calculated for each ply (determined by the length of ``ply_angles``) at each critical point (4 total),
+(hence 4 x ``numplies`` strength ratio values for each beam element) for all beam elements are aggregated using a **KS Aggregate** function:
+
+.. math::
+
+    \hat{g}_{KS}(\rho, g) = \max_j g_j + \frac{1}{\rho} \ln \left( \sum_{j=1}^{n_g} \exp \left( \rho (g_j - \max_j g_j) \right) \right)
+
+
+where :math:`g` is :math:`\left( \frac{SR}{SR_{\text{lim}}} - 1 \right)` value for each ply and :math:`SR_{\text{lim}}` is defined as:
+
+.. math::
+
+    SR_{\text{lim}} = \frac{1}{\text{safety factor}}
+
+
+The failure is determined by the value of :math:`\hat{g}_{KS}(\rho, g)` exceeding 0.
+
+
+Example runscript
+-----------------
+
+Here is an example runscript of composite wing aerostructural optimization.
+This roughly follows the setup of "Simple Transonic Wing" by `Gray and Martins 2024 <https://www.researchgate.net/publication/377154425_A_Proposed_Benchmark_Model_for_Practical_Aeroelastic_Optimization_of_Aircraft_Wings>`_.
+
+.. embed-code::
+  ../examples/run_aerostruct_composite_benchmark_wing.py
diff --git a/openaerostruct/docs/advanced_features/scripts/two_part_wing_custom_mesh.py b/openaerostruct/docs/advanced_features/scripts/two_part_wing_custom_mesh.py
index 81ef249e4..eb50882b6 100644
--- a/openaerostruct/docs/advanced_features/scripts/two_part_wing_custom_mesh.py
+++ b/openaerostruct/docs/advanced_features/scripts/two_part_wing_custom_mesh.py
@@ -160,7 +160,8 @@
     # Structural values are based on aluminum 7075
     "E": 73.1e9,  # [Pa] Young's modulus
     "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-    "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+    "yield": 420.0e6,  # [Pa] yield stress
+    "safety_factor": 1.5,  # safety factor
     "mrho": 2.78e3,  # [kg/m^3] material density
     "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
     "wing_weight_ratio": 1.25,
diff --git a/openaerostruct/docs/advanced_features/scripts/wingbox_mpt_Q400_example.py b/openaerostruct/docs/advanced_features/scripts/wingbox_mpt_Q400_example.py
index 77aa0911f..5126c87c8 100644
--- a/openaerostruct/docs/advanced_features/scripts/wingbox_mpt_Q400_example.py
+++ b/openaerostruct/docs/advanced_features/scripts/wingbox_mpt_Q400_example.py
@@ -93,7 +93,8 @@
     # Structural values are based on aluminum 7075
     "E": 73.1e9,  # [Pa] Young's modulus
     "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-    "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+    "yield": 420.0e6,  # [Pa] yield stress
+    "safety_factor": 1.5,  # safety factor
     "mrho": 2.78e3,  # [kg/m^3] material density
     "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
     "wing_weight_ratio": 1.25,
diff --git a/openaerostruct/docs/aerostructural_wingbox_walkthrough.rst b/openaerostruct/docs/aerostructural_wingbox_walkthrough.rst
index 878eda108..cb7f8c246 100644
--- a/openaerostruct/docs/aerostructural_wingbox_walkthrough.rst
+++ b/openaerostruct/docs/aerostructural_wingbox_walkthrough.rst
@@ -100,10 +100,10 @@ The `c_max_t` value is the location of the maximum thickness of the airfoil alon
   :end-before: checkpoint 6
 
 Next we provide some information related to structures.
-We provide the Young's and shear moduli, as well as the allowable yield stress and density of the material being used (the wingbox model currently assumes that the material is isotropic).
-Here we use include a safety factor of 1.5 in the allowable yield stress.
+We provide the Young's and shear moduli, as well as the maximum yield stress and density of the material being used. The material can either be assumed to be isotropic (like aluminum) or orthotropic (like carbon fiber reinforced polymer).
+Here we use include a safety factor of 1.5 using the `safety_factor` key.
 The `strength_factor_for_upper_skin` value can be used to adjust the yield strength of the upper skin relative to the lower skin.
-For example, if we were using different alloys for the top and bottom skin (e.g., Al7075 vs Al2024) we would provide the allowable yield stress of the lower skin for `yield` and the ratio of the yield strengths of the upper skin to the lower skin for `strength_factor_for_upper_skin`.
+For example, if we were using different alloys for the top and bottom skin (e.g., Al7075 vs Al2024) we would provide the maximum yield stress of the lower skin for `yield` and the ratio of the yield strengths of the upper skin to the lower skin for `strength_factor_for_upper_skin`.
 The `wing_weight_ratio` number is used to estimate the weight of other components not modeled in the wingbox structure (e.g., overlaps, fasteners, etc.).
 With the `exact_failure_constraint` set to `False`, we aggregate the stress constraints for the FEM elements into a single constraint using the  Kreisselmeier--Steinhauser function.
 This helps reduce computational cost during optimization by replacing a large number of constraints (one for each stress combination for each element) with a single constraint.
diff --git a/openaerostruct/docs/user_reference/mesh_surface_dict.rst b/openaerostruct/docs/user_reference/mesh_surface_dict.rst
index f43a286d7..e4c102ccc 100644
--- a/openaerostruct/docs/user_reference/mesh_surface_dict.rst
+++ b/openaerostruct/docs/user_reference/mesh_surface_dict.rst
@@ -243,9 +243,13 @@ The surface dict will be provided to Groups, including ``Geometry``, ``AeroPoint
       - Pa
       - Shear modulus
     * - yield
-      - 420.0e6 / 1.5
+      - 420.0e6
       - Pa
-      - Allowable yield stress including the safety factor.
+      - Maximum yield stress of the material.
+    * - safety_factor
+      - 1.5
+      -
+      - Factor of safety for the material.
     * - mrho
       - 2.78e3
       - kg/m^3
diff --git a/openaerostruct/docs/wingbox_mpt_opt_example.py b/openaerostruct/docs/wingbox_mpt_opt_example.py
index c9e95a5ae..7337f01b4 100644
--- a/openaerostruct/docs/wingbox_mpt_opt_example.py
+++ b/openaerostruct/docs/wingbox_mpt_opt_example.py
@@ -76,7 +76,8 @@
     # Structural values are based on aluminum 7075
     "E": 73.1e9,  # [Pa] Young's modulus
     "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-    "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+    "yield": 420.0e6,  # [Pa] yield stress
+    "safety_factor": 1.5,  # safety factor
     "mrho": 2.78e3,  # [kg/m^3] material density
     "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
     "wing_weight_ratio": 1.25,
diff --git a/openaerostruct/examples/black_box_example.py b/openaerostruct/examples/black_box_example.py
index 699ee5a1e..d78c4ee99 100644
--- a/openaerostruct/examples/black_box_example.py
+++ b/openaerostruct/examples/black_box_example.py
@@ -52,7 +52,8 @@
     # Structural values are based on aluminum 7075
     "E": 70.0e9,  # [Pa] Young's modulus of the spar
     "G": 30.0e9,  # [Pa] shear modulus of the spar
-    "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+    "yield": 500.0e6,
+    "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
     "mrho": 3.0e3,  # [kg/m^3] material density
     "fem_origin": 0.35,  # normalized chordwise location of the spar
     "wing_weight_ratio": 2.0,
diff --git a/openaerostruct/examples/run_CRM.py b/openaerostruct/examples/run_CRM.py
index d530b48ca..bec25370f 100644
--- a/openaerostruct/examples/run_CRM.py
+++ b/openaerostruct/examples/run_CRM.py
@@ -42,7 +42,8 @@
     # Structural values are based on aluminum 7075
     "E": 70.0e9,  # [Pa] Young's modulus of the spar
     "G": 30.0e9,  # [Pa] shear modulus of the spar
-    "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+    "yield": 500.0e6,
+    "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
     "mrho": 3.0e3,  # [kg/m^3] material density
     "fem_origin": 0.35,  # normalized chordwise location of the spar
     "wing_weight_ratio": 2.0,
diff --git a/openaerostruct/examples/run_aerostruct_composite_benchmark_wing.py b/openaerostruct/examples/run_aerostruct_composite_benchmark_wing.py
new file mode 100644
index 000000000..75ddbfb2f
--- /dev/null
+++ b/openaerostruct/examples/run_aerostruct_composite_benchmark_wing.py
@@ -0,0 +1,424 @@
+"""
+Aerostructural optimization example of the "Simple Composite Wing" from:
+Gray and Martins, A Proposed Benchmark Model for Practical Aeroelastic Optimization of Aircraft Wings, AIAA 2024-2775.
+https://www.researchgate.net/publication/377154425_A_Proposed_Benchmark_Model_for_Practical_Aeroelastic_Optimization_of_Aircraft_Wings
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from openaerostruct.geometry.utils import generate_mesh
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+from openaerostruct.structures.utils import compute_composite_stiffness
+import openmdao.api as om
+
+# --- Case control ---
+# case_name = "Analysis"   # trim analysis for an initial design.
+case_name = "Case1"  # structural optimization
+# case_name = "Case2"  # aerostructural optimization with fixed planform
+# case_name = "Case3"  # aerostructural optimization with varying planform (span, chord, and sweep)
+
+# --- Airfoil definition for wingbox structure model ---
+# We use the 15% to 65% chord portion of the RAE2822 airfoil.
+# fmt: off
+upper_x = np.array([0.15, 0.17, 0.19, 0.21, 0.23, 0.25, 0.27, 0.29, 0.31, 0.33, 0.35, 0.37, 0.39, 0.41, 0.43, 0.45, 0.47, 0.49, 0.51, 0.53, 0.55, 0.57, 0.59, 0.61, 0.63, 0.65], dtype="complex128")
+lower_x = np.array([0.15, 0.17, 0.19, 0.21, 0.23, 0.25, 0.27, 0.29, 0.31, 0.33, 0.35, 0.37, 0.39, 0.41, 0.43, 0.45, 0.47, 0.49, 0.51, 0.53, 0.55, 0.57, 0.59, 0.61, 0.63, 0.65], dtype="complex128")
+upper_y = np.array([0.04591116991110611,   0.04839609476913142,   0.05062208326872383,  0.05261581485173187,   0.054397682405710426, 0.055983808645155245,  0.057386804014598544, 0.05861859395614192,  0.05968942721753942,  0.060589981875354845,  0.0613225097626915,   0.061904166920345005,  0.06233885550219253,   0.06262971153846154,  0.06277830920512399,   0.06277420344063064,  0.06258449250255363,  0.062233206407434585, 0.061713111844786825,  0.0610172702757916,  0.060139111717851856, 0.0590313764575464,   0.05772568052109181,   0.05624323825433285,  0.05459345628276678,   0.05278581315710423], dtype="complex128")  # noqa: E201, E241
+lower_y = np.array([-0.04604238094970181, -0.048404951781293726, -0.05050769979841836, -0.052371999003239474, -0.05401536186939327, -0.055450351894347404, -0.05668039589416059, -0.057700571759671956, -0.05849340424509761, -0.05900613517054636, -0.05919639050765996, -0.059068267715203786, -0.058614112758404675, -0.05783551674937965, -0.056741090244703564, -0.05532706495319429, -0.05358094598569969, -0.05159666756338143, -0.049403792369772555, -0.0470318138100102, -0.04450996703071111, -0.04184532587452785, -0.039089564516129036, -0.03626824702443099, -0.033399043294435986, -0.03049965785521177], dtype="complex128")
+# fmt: on
+
+# --- Geometry and analysis options ---
+# Create a dictionary to store options about the surface
+mesh_dict = {
+    "num_y": 51,
+    "num_x": 7,
+    "wing_type": "rect",
+    "symmetry": True,
+    "chord_cos_spacing": 0,
+    "span_cos_spacing": 0,
+    "root_chord": 1.0,  # apply chord later.
+    "span": 28.0,
+}
+
+mesh = generate_mesh(mesh_dict)
+
+surf_dict = {
+    # Wing definition
+    "name": "wing",  # name of the surface
+    "symmetry": True,  # if true, model one half of wing
+    "S_ref_type": "wetted",  # how we compute the wing area, can be 'wetted' or 'projected'
+    "mesh": mesh,
+    # planform defition
+    "span": 28.0,
+    "chord_cp": np.array([1.5, 5.0]),  # tip, root [m]
+    "sweep": 28.18,  # leading edge sweep [deg]
+    "ref_axis_pos": 0,  # set this to 0 to define the sweep for leading edge.
+    # twist distribution
+    "twist_cp": np.zeros(5),
+    "fem_model_type": "wingbox",
+    "data_x_upper": upper_x,
+    "data_x_lower": lower_x,
+    "data_y_upper": upper_y,
+    "data_y_lower": lower_y,
+    "spar_thickness_cp": np.linspace(0.003, 0.02, 10),  # initial guess, [m]
+    "skin_thickness_cp": np.linspace(0.003, 0.02, 10),  # initial guess, [m]
+    "original_wingbox_airfoil_t_over_c": 0.121,
+    # Aerodynamic parameters and options
+    "CL0": 0.0,
+    "CD0": 0.01508,  # CD0 = 0.01508 for fuselage + nacelle + tails from Gray 2024 + wing drag calibration to match Case 1 L/D
+    "with_viscous": True,  # if true, compute viscous drag
+    "with_wave": True,  # if true, compute wave drag
+    # Airfoil properties for viscous drag calculation
+    "k_lam": 0.05,  # percentage of chord with laminar flow, used for viscous drag
+    "c_max_t": 0.38,  # chordwise location of maximum thickness
+    "t_over_c_cp": np.array([0.121, 0.121, 0.121, 0.121, 0.121]),
+    "wing_weight_ratio": 3.03,  # from Case 1 results of Gray 2024 (they used nonlinear weight model)
+    "exact_failure_constraint": False,  # if false, use KS function
+    "struct_weight_relief": True,
+    "distributed_fuel_weight": True,
+    "fuel_density": 804.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+    "Wf_reserve": 2000.0,  # [kg] reserve fuel mass
+    # Composite material parameters
+    "useComposite": True,
+    "mrho": 1550,  # [kg/m^3]
+    "safety_factor": 1.5,
+    "ply_angles": [0, 45, -45, 90],
+    "ply_fractions": [0.4441, 0.222, 0.222, 0.1119],  # skin layup from Gray 2024
+    "E1": 117.7e9,
+    "E2": 9.7e9,
+    "nu12": 0.35,
+    "G12": 4.8e9,
+    "sigma_t1": 1648.0e6,  # longitudinal tensile strength
+    "sigma_c1": 1034.0e6,  # longitudinal compressive strength
+    "sigma_t2": 64.0e6,  # transverse tensile strength
+    "sigma_c2": 228.0e6,  # transverse compressive strength
+    "sigma_12max": 71.0e6,  # maximum shear strength
+}
+
+# Compute effective E and G for composite material
+compute_composite_stiffness(surf_dict)
+
+surfaces = [surf_dict]
+
+# --- OpenMDAO problem setup ---
+prob = om.Problem()
+
+# flight conditions (cruise, 2.5g pull-up maneuver)
+mach_number = np.array([0.77, 0.458])  # cruise, 2.5g maneuver
+speed_of_sound = np.array([297.71, 340.294])
+v = mach_number * speed_of_sound
+rho_air = np.array([0.39263, 1.225])
+mu_air = np.array([1.454e-5, 1.812e-5])
+
+# Add problem information as an independent variables component
+indep_var_comp = om.IndepVarComp()
+indep_var_comp.add_output("v", val=v, units="m/s")
+indep_var_comp.add_output("alpha", val=4.0, units="deg")  # initial guess
+indep_var_comp.add_output("alpha_maneuver", val=9.0, units="deg")  # initial guess
+indep_var_comp.add_output("Mach_number", val=mach_number)
+indep_var_comp.add_output("re", val=rho_air * v / mu_air, units="1/m")
+indep_var_comp.add_output("rho", val=rho_air, units="kg/m**3")
+indep_var_comp.add_output("CT", val=0.64 / 3600, units="1/s")  # 0.64 lbm/lbf-h = 1.81e-5 kg/N-s
+indep_var_comp.add_output("R", val=3815, units="km")
+indep_var_comp.add_output("W0", val=39500 + surf_dict["Wf_reserve"], units="kg")
+indep_var_comp.add_output("speed_of_sound", val=speed_of_sound, units="m/s")
+indep_var_comp.add_output("load_factor", val=np.array([1.0, 2.5]))
+indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+indep_var_comp.add_output("fuel_mass", val=10000, units="kg")  # initial guess
+
+prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+# Compute mid-cruise fuel mass
+mid_cruise_fuel_mass_comp = om.ExecComp("fuel_mid_cruise = fuel_mass / 2", units="kg")
+prob.model.add_subsystem(
+    "mid_cruise_fuel_mass",
+    mid_cruise_fuel_mass_comp,
+    promotes_inputs=["fuel_mass"],
+    promotes_outputs=["fuel_mid_cruise"],
+)
+
+# Add geometry groups
+for surface in surfaces:
+    # Get the surface name and create a group to contain components
+    # only for this surface
+    name = surface["name"]
+
+    aerostruct_group = AerostructGeometry(surface=surface)
+
+    # Add group to the problem with the name of the surface.
+    prob.model.add_subsystem(name, aerostruct_group)
+
+# Add analysis flight conditions
+for i in range(2):
+    point_name = "AS_point_{}".format(i)
+    # Connect the parameters within the model for each aerostruct point
+
+    # Create the aerostruct point group and add it to the model
+    AS_point = AerostructPoint(surfaces=surfaces, internally_connect_fuelburn=False)
+
+    prob.model.add_subsystem(point_name, AS_point)
+
+    # Connect flow properties to the analysis point
+    prob.model.connect("v", point_name + ".v", src_indices=[i])
+    prob.model.connect("Mach_number", point_name + ".Mach_number", src_indices=[i])
+    prob.model.connect("re", point_name + ".re", src_indices=[i])
+    prob.model.connect("rho", point_name + ".rho", src_indices=[i])
+    prob.model.connect("CT", point_name + ".CT")
+    prob.model.connect("R", point_name + ".R")
+    prob.model.connect("W0", point_name + ".W0")
+    prob.model.connect("speed_of_sound", point_name + ".speed_of_sound", src_indices=[i])
+    prob.model.connect("empty_cg", point_name + ".empty_cg")
+    prob.model.connect("load_factor", point_name + ".load_factor", src_indices=[i])
+    prob.model.connect("fuel_mass", point_name + ".total_perf.L_equals_W.fuelburn")
+    prob.model.connect("fuel_mass", point_name + ".total_perf.CG.fuelburn")
+
+    for surface in surfaces:
+        name = surface["name"]
+
+        if surf_dict["distributed_fuel_weight"]:
+            prob.model.connect("load_factor", point_name + ".coupled.load_factor", src_indices=[i])
+
+        com_name = point_name + "." + name + "_perf."
+        prob.model.connect(
+            name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+        )
+        prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+        # Connect aerodyamic mesh to coupled group mesh
+        prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+        if surf_dict["struct_weight_relief"]:
+            prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+        # Connect performance calculation variables
+        prob.model.connect(name + ".nodes", com_name + "nodes")
+        prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+        prob.model.connect(name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass")
+
+        # Connect wingbox properties to von Mises stress calcs
+        prob.model.connect(name + ".Qz", com_name + "Qz")
+        prob.model.connect(name + ".J", com_name + "J")
+        prob.model.connect(name + ".A_enc", com_name + "A_enc")
+        prob.model.connect(name + ".htop", com_name + "htop")
+        prob.model.connect(name + ".hbottom", com_name + "hbottom")
+        prob.model.connect(name + ".hfront", com_name + "hfront")
+        prob.model.connect(name + ".hrear", com_name + "hrear")
+
+        prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+        prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+prob.model.connect("alpha", "AS_point_0" + ".alpha")
+prob.model.connect("alpha_maneuver", "AS_point_1" + ".alpha")
+
+# Here we add the fuel volume constraint componenet to the model
+prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+
+if surf_dict["distributed_fuel_weight"]:
+    prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
+    prob.model.connect("fuel_mid_cruise", "AS_point_0.coupled.wing.struct_states.fuel_mass")
+
+    prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_1.coupled.wing.struct_states.fuel_vols")
+    # set zero fuel for maneuver points
+    prob.model.set_input_defaults("AS_point_1.coupled.wing.struct_states.fuel_mass", 0.0)
+
+comp = om.ExecComp("fuel_diff = (fuel_mass - fuelburn) / fuelburn", units="kg")
+prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
+prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
+
+# compute wing loading
+wing_loading_group = prob.model.add_subsystem("wing_loading", om.Group(), promotes=["*"])
+mtow_comp = om.ExecComp("MTOW = W0 + fuel_mass + wing_str_mass", units="kg")
+wing_loading_group.add_subsystem("MTOW", mtow_comp, promotes_inputs=["W0", "fuel_mass"], promotes_outputs=["MTOW"])
+prob.model.connect("wing.structural_mass", "MTOW.wing_str_mass")
+
+wing_loading_comp = om.ExecComp(
+    "wing_loading = MTOW / wing_area",
+    wing_loading={"units": "kg/m**2"},
+    MTOW={"units": "kg"},
+    wing_area={"units": "m**2"},
+)
+wing_loading_group.add_subsystem(
+    "wing_loading", wing_loading_comp, promotes_inputs=["MTOW"], promotes_outputs=["wing_loading"]
+)
+prob.model.connect("AS_point_0.coupled.wing.S_ref", "wing_loading.wing_area")
+
+# --- Optimizer settings ---
+## Use these settings if you do not have pyOptSparse or SNOPT
+# prob.driver = om.ScipyOptimizeDriver()
+# prob.driver.options["optimizer"] = "SLSQP"
+# prob.driver.options["tol"] = 1e-8
+
+prob.driver = om.pyOptSparseDriver()
+prob.driver.options["print_results"] = True
+prob.driver.options["optimizer"] = "SNOPT"
+prob.driver.opt_settings["Major iterations limit"] = 100
+prob.driver.opt_settings["Major feasibility tolerance"] = 1e-6
+prob.driver.opt_settings["Major optimality tolerance"] = 1e-6
+prob.driver.opt_settings["Verify level"] = -1
+prob.driver.opt_settings["Function precision"] = 1e-10
+prob.driver.opt_settings["Hessian full memory"] = 1
+prob.driver.opt_settings["Hessian frequency"] = 100
+
+# --- Define optimization problem ---
+if case_name == "Case1":
+    prob.model.add_objective("wing.structural_mass", units="kg", ref=1000)
+else:
+    prob.model.add_objective("AS_point_0.fuelburn", units="kg", ref=10000)
+
+# angle of attack and L=W constraint.
+prob.model.add_design_var("alpha", lower=0.0, upper=20, ref=10)
+prob.model.add_design_var("alpha_maneuver", lower=0.0, upper=30, ref=10)
+prob.model.add_constraint("AS_point_0.L_equals_W", equals=0.0)
+prob.model.add_constraint("AS_point_1.L_equals_W", equals=0.0)
+
+# structural design variables and failure constraint
+if case_name in ["Case1", "Case2", "Case3"]:
+    prob.model.add_design_var("wing.spar_thickness_cp", lower=0.002, upper=0.1, ref=0.01)
+    prob.model.add_design_var("wing.skin_thickness_cp", lower=0.002, upper=0.1, ref=0.01)
+    prob.model.add_constraint("AS_point_1.wing_perf.failure", upper=0.0)
+
+# twist and t/c variables
+if case_name in ["Case2", "Case3"]:
+    twist_indices = range(len(surf_dict["twist_cp"]) - 1)  # exclude root twist = last index
+    prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1, indices=twist_indices)
+    prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+
+# planform variable
+if case_name in ["Case3"]:
+    prob.model.add_design_var("wing.geometry.span", lower=25, upper=40, ref=28.0)
+    prob.model.add_design_var("wing.geometry.chord_cp", lower=1.0, upper=8.0, ref=1.5)
+    prob.model.add_design_var("wing.sweep", lower=15.0, upper=35.0, ref=28.18)
+
+    # constraint wing loading
+    prob.model.add_constraint("wing_loading", units="kg/m**2", upper=600, ref=600)
+
+# fuel mass variable and consistency constraint
+if case_name in ["Case2", "Case3"]:
+    prob.model.add_design_var("fuel_mass", lower=5000, upper=20000, ref=10000)
+    prob.model.add_constraint("fuel_diff", equals=0.0)
+    prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+
+# Set up the problem
+prob.setup()
+
+# change linear solver for aerostructural coupled adjoint
+prob.model.AS_point_0.coupled.linear_solver = om.PETScKrylov(assemble_jac=True, iprint=0, rhs_checking=True)
+prob.model.AS_point_0.coupled.linear_solver.precon = om.LinearRunOnce(iprint=-1)
+prob.model.AS_point_1.coupled.linear_solver = om.PETScKrylov(assemble_jac=True, iprint=0, rhs_checking=True)
+prob.model.AS_point_1.coupled.linear_solver.precon = om.LinearRunOnce(iprint=-1)
+
+# Use LinearBlockGS instead if you don't have PETSc installed
+# prob.model.AS_point_0.coupled.linear_solver = om.LinearBlockGS(iprint=0, maxiter=30, use_aitken=True)
+# prob.model.AS_point_1.coupled.linear_solver = om.LinearBlockGS(iprint=0, maxiter=30, use_aitken=True)
+
+prob.run_driver()
+
+om.n2(prob, show_browser=False, outfile="n2_simple_transonic_wing.html")
+
+# --- Print results ---
+fuel_burn = prob.get_val("AS_point_0.fuelburn", units="kg")[0]
+wing_mass = prob.get_val("wing.structural_mass", units="kg")[0]
+cruise_CD = prob.get_val("AS_point_0.CD")[0]
+cruise_CL = prob.get_val("AS_point_0.CL")[0]
+cruise_LbyD = cruise_CL / cruise_CD
+
+print("\n--------------------------------")
+print("Fuel burn =", fuel_burn, "[kg]")
+print("Wingbox structure mass =", wing_mass / surf_dict["wing_weight_ratio"], "[kg]")
+print("Wing total mass =", wing_mass, "[kg]")
+print("Cruise CD =", cruise_CD)
+print("Cruise CL =", cruise_CL)
+print("Cruise L/D =", cruise_LbyD)
+
+print("\nComposite effective stiffness:")
+print("E =", surf_dict["E"] / 1e9)
+print("G =", surf_dict["G"] / 1e9)
+
+print("\nStructural variables")
+print("Spar thickness cp =", prob.get_val("wing.spar_thickness_cp", units="mm"), "[mm] (tip to root)")
+print("Skin thickness cp =", prob.get_val("wing.skin_thickness_cp", units="mm"), "[mm] (tip to root)")
+
+print("\nAero/aerostructural variables")
+print("Twist cp =", prob.get_val("wing.twist_cp", units="deg"), "[deg] (tip to root)")
+print("t/c cp =", prob.get_val("wing.geometry.t_over_c_cp"), "(tip to root)")
+
+print("\nPlanform variables")
+print("Span =", prob.get_val("wing.geometry.span", units="m"), "[m]")
+print("Chord cp =", prob.get_val("wing.geometry.chord_cp"), "[m] (tip, root)")
+print("LE sweep =", prob.get_val("wing.sweep", units="deg"), "[deg]")
+
+# --- plot planform ---
+mesh = prob.get_val("wing.mesh")
+mesh_x = mesh[:, :, 0]
+mesh_y = mesh[:, ::-1, 1] * -1
+le_root_x = mesh[0, -1, 0]
+mesh_x -= le_root_x
+
+plt.figure()
+plt.plot(mesh_y[0, :], mesh_x[0, :], color="k")  # LE
+plt.plot(mesh_y[-1, :], mesh_x[-1, :], color="k")  # TE
+plt.plot(mesh_y[:, 0], mesh_x[:, 0], color="k")  # tip
+plt.plot(mesh_y[:, -1], mesh_x[:, -1], color="k")  # root
+plt.axis("equal")
+plt.gca().invert_xaxis()
+plt.grid()
+plt.savefig("simple_transonic_wing_planform.pdf", bbox_inches="tight")
+
+# --- plot structural thickness ---
+y = mesh_y[0, :]
+skin_thickness = prob.get_val("wing.skin_thickness", units="mm").ravel()[::-1]
+spar_thickness = prob.get_val("wing.spar_thickness", units="mm").ravel()[::-1]
+skin_t_step = np.concatenate([[skin_thickness[0]], skin_thickness])
+spar_t_step = np.concatenate([[spar_thickness[0]], spar_thickness])
+
+fig, axs = plt.subplots(2, 1, figsize=(6, 6))
+axs[0].step(y, skin_t_step, where="pre", lw=2)
+axs[0].set_ylabel("Skin Thickness (mm)")
+axs[0].set_xticklabels([])
+
+axs[1].step(y, spar_t_step, where="pre", lw=2)
+axs[1].set_ylabel("Spar Thickness (mm)")
+axs[1].set_xlabel("Spanwise (m)")
+plt.savefig("simple_transonic_wing_thickness.pdf", bbox_inches="tight")
+
+# --- plot twist and t/c---
+# jig twist
+jig_mesh = prob.get_val("wing.mesh", units="m")
+jig_LE = jig_mesh[0, :, :]
+jig_TE = jig_mesh[-1, :, :]
+jig_chord = jig_TE[:, 0] - jig_LE[:, 0]
+twist_jig = np.arctan2(jig_LE[:, 2] - jig_TE[:, 2], jig_chord) * 180 / np.pi
+
+# cruise twist
+cruise_mesh = prob.get_val("AS_point_0.coupled.wing.def_mesh", units="m")
+cruise_LE = cruise_mesh[0, :, :]
+cruise_TE = cruise_mesh[-1, :, :]
+cruise_chord = cruise_TE[:, 0] - cruise_LE[:, 0]
+twist_cruise = np.arctan2(cruise_LE[:, 2] - cruise_TE[:, 2], cruise_chord) * 180 / np.pi
+
+# 2.5g twist
+maneuver_mesh = prob.get_val("AS_point_1.coupled.wing.def_mesh", units="m")
+maneuver_LE = maneuver_mesh[0, :, :]
+maneuver_TE = maneuver_mesh[-1, :, :]
+maneuver_chord = maneuver_TE[:, 0] - maneuver_LE[:, 0]
+twist_maneuver = np.arctan2(maneuver_LE[:, 2] - maneuver_TE[:, 2], maneuver_chord) * 180 / np.pi
+
+fig, axs = plt.subplots(2, 1, figsize=(6, 6))
+axs[0].plot(y, twist_jig[::-1], color="darkgray", label="jig")
+axs[0].plot(y, twist_cruise[::-1], color="C0", label="1g cruise")
+axs[0].plot(y, twist_maneuver[::-1], color="C1", label="2.5g pull-up")
+axs[0].set_xticklabels([])
+axs[0].set_ylabel("Twist (deg)")
+axs[0].legend()
+
+# t/c
+t_over_c = prob.get_val("wing.t_over_c").ravel()[::-1]
+t_over_c_step = np.concatenate([[t_over_c[0]], t_over_c])
+axs[1].step(y, t_over_c_step, where="pre", color="C0")
+axs[1].set_xlabel("Spanwise (m)")
+axs[1].set_ylabel("t/c")
+axs[1].set_xlabel("Spanwise (m)")
+plt.savefig("simple_transonic_wing_twist_tc.pdf", bbox_inches="tight")
+
+plt.show()
diff --git a/openaerostruct/examples/run_aerostruct_uCRM_composite_wingbox.py b/openaerostruct/examples/run_aerostruct_uCRM_composite_wingbox.py
new file mode 100644
index 000000000..2944240eb
--- /dev/null
+++ b/openaerostruct/examples/run_aerostruct_uCRM_composite_wingbox.py
@@ -0,0 +1,300 @@
+"""
+This example is a composite material version of the uCRM multipoint optimization with the wingbox structure model.
+Original uCRM runscript with Aluminum material can be found in run_aerostruct_uCRM_multipoint.py.
+"""
+
+import numpy as np
+from openaerostruct.geometry.utils import generate_mesh
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+from openaerostruct.structures.wingbox_fuel_vol_delta import WingboxFuelVolDelta
+from openaerostruct.structures.utils import compute_composite_stiffness
+import openmdao.api as om
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower surfaces must be the same
+
+# fmt: off
+upper_x = np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6], dtype="complex128")
+lower_x = np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6], dtype="complex128")
+upper_y = np.array([ 0.0447,  0.046,  0.0472,  0.0484,  0.0495,  0.0505,  0.0514,  0.0523,  0.0531,  0.0538, 0.0545,  0.0551,  0.0557, 0.0563,  0.0568, 0.0573,  0.0577,  0.0581,  0.0585,  0.0588,  0.0591,  0.0593,  0.0595,  0.0597,  0.0599,  0.06,    0.0601,  0.0602,  0.0602,  0.0602,  0.0602,  0.0602,  0.0601,  0.06,    0.0599,  0.0598,  0.0596,  0.0594,  0.0592,  0.0589,  0.0586,  0.0583,  0.058,   0.0576,  0.0572,  0.0568,  0.0563,  0.0558,  0.0553,  0.0547,  0.0541], dtype="complex128")  # noqa: E201, E241
+lower_y = np.array([-0.0447, -0.046, -0.0473, -0.0485, -0.0496, -0.0506, -0.0515, -0.0524, -0.0532, -0.054, -0.0547, -0.0554, -0.056, -0.0565, -0.057, -0.0575, -0.0579, -0.0583, -0.0586, -0.0589, -0.0592, -0.0594, -0.0595, -0.0596, -0.0597, -0.0598, -0.0598, -0.0598, -0.0598, -0.0597, -0.0596, -0.0594, -0.0592, -0.0589, -0.0586, -0.0582, -0.0578, -0.0573, -0.0567, -0.0561, -0.0554, -0.0546, -0.0538, -0.0529, -0.0519, -0.0509, -0.0497, -0.0485, -0.0472, -0.0458, -0.0444], dtype="complex128")
+# fmt: on
+
+# Create a dictionary to store options about the surface
+mesh_dict = {
+    "num_y": 51,
+    "num_x": 7,
+    "wing_type": "uCRM_based",
+    "symmetry": True,
+    "chord_cos_spacing": 0,
+    "span_cos_spacing": 0,
+    "num_twist_cp": 6,
+}
+
+mesh, twist_cp = generate_mesh(mesh_dict)
+
+surf_dict = {
+    # Wing definition
+    "name": "wing",  # name of the surface
+    "symmetry": True,  # if true, model one half of wing
+    "S_ref_type": "wetted",  # how we compute the wing area,
+    # can be 'wetted' or 'projected'
+    "mesh": mesh,
+    "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+    "fem_model_type": "wingbox",
+    "data_x_upper": upper_x,
+    "data_x_lower": lower_x,
+    "data_y_upper": upper_y,
+    "data_y_lower": lower_y,
+    "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+    "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+    "original_wingbox_airfoil_t_over_c": 0.12,
+    # Aerodynamic deltas.
+    # These CL0 and CD0 values are added to the CL and CD
+    # obtained from aerodynamic analysis of the surface to get
+    # the total CL and CD.
+    # These CL0 and CD0 values do not vary wrt alpha.
+    # They can be used to account for things that are not included, such as contributions from the fuselage, nacelles, tail surfaces, etc.
+    "CL0": 0.0,
+    "CD0": 0.0078,
+    "with_viscous": True,  # if true, compute viscous drag
+    "with_wave": True,  # if true, compute wave drag
+    # Airfoil properties for viscous drag calculation
+    "k_lam": 0.05,  # percentage of chord with laminar
+    # flow, used for viscous drag
+    "c_max_t": 0.38,  # chordwise location of maximum thickness
+    "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+    "wing_weight_ratio": 1.25,
+    "exact_failure_constraint": False,  # if false, use KS function
+    "struct_weight_relief": True,
+    "distributed_fuel_weight": True,
+    "fuel_density": 803.0,  # [kg/m^3] fuel density (only needed if the fuel-in-wing volume constraint is used)
+    "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+    # Composite material parameters
+    "useComposite": True,
+    "mrho": 1550,  # [kg/m^3]
+    "safety_factor": 1.5,
+    "ply_angles": [0, 45, -45, 90],
+    "ply_fractions": [0.625, 0.125, 0.125, 0.125],
+    "E1": 117.7e9,
+    "E2": 9.7e9,
+    "nu12": 0.35,
+    "G12": 4.8e9,
+    "sigma_t1": 1648.0e6,  # longitudinal tensile strength
+    "sigma_c1": 1034.0e6,  # longitudinal compressive strength
+    "sigma_t2": 64.0e6,  # transverse tensile strength
+    "sigma_c2": 228.0e6,  # transverse compressive strength
+    "sigma_12max": 71.0e6,  # maximum shear strength
+}
+
+# Compute effective E and G for composite material
+compute_composite_stiffness(surf_dict)
+
+surfaces = [surf_dict]
+
+# Create the problem and assign the model group
+prob = om.Problem()
+
+# Add problem information as an independent variables component
+indep_var_comp = om.IndepVarComp()
+indep_var_comp.add_output("v", val=np.array([0.85 * 295.07, 0.64 * 340.294]), units="m/s")
+indep_var_comp.add_output("alpha", val=0.0, units="deg")
+indep_var_comp.add_output("alpha_maneuver", val=0.0, units="deg")
+indep_var_comp.add_output("Mach_number", val=np.array([0.85, 0.64]))
+indep_var_comp.add_output(
+    "re",
+    val=np.array([0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), 1.225 * 340.294 * 0.64 * 1.0 / (1.81206 * 1e-5)]),
+    units="1/m",
+)
+indep_var_comp.add_output("rho", val=np.array([0.348, 1.225]), units="kg/m**3")
+indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+indep_var_comp.add_output("R", val=14.307e6, units="m")
+indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+indep_var_comp.add_output("speed_of_sound", val=np.array([295.07, 340.294]), units="m/s")
+indep_var_comp.add_output("load_factor", val=np.array([1.0, 2.5]))
+indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+indep_var_comp.add_output("fuel_mass", val=10000.0, units="kg")
+
+prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+# Loop over each surface in the surfaces list
+for surface in surfaces:
+    # Get the surface name and create a group to contain components
+    # only for this surface
+    name = surface["name"]
+
+    aerostruct_group = AerostructGeometry(surface=surface)
+
+    # Add group to the problem with the name of the surface.
+    prob.model.add_subsystem(name, aerostruct_group)
+
+# Loop through and add a certain number of aerostruct points
+for i in range(2):
+    point_name = "AS_point_{}".format(i)
+    # Connect the parameters within the model for each aerostruct point
+
+    # Create the aerostruct point group and add it to the model
+    AS_point = AerostructPoint(surfaces=surfaces, internally_connect_fuelburn=False)
+
+    prob.model.add_subsystem(point_name, AS_point)
+
+    # Connect flow properties to the analysis point
+    prob.model.connect("v", point_name + ".v", src_indices=[i])
+    prob.model.connect("Mach_number", point_name + ".Mach_number", src_indices=[i])
+    prob.model.connect("re", point_name + ".re", src_indices=[i])
+    prob.model.connect("rho", point_name + ".rho", src_indices=[i])
+    prob.model.connect("CT", point_name + ".CT")
+    prob.model.connect("R", point_name + ".R")
+    prob.model.connect("W0", point_name + ".W0")
+    prob.model.connect("speed_of_sound", point_name + ".speed_of_sound", src_indices=[i])
+    prob.model.connect("empty_cg", point_name + ".empty_cg")
+    prob.model.connect("load_factor", point_name + ".load_factor", src_indices=[i])
+    prob.model.connect("fuel_mass", point_name + ".total_perf.L_equals_W.fuelburn")
+    prob.model.connect("fuel_mass", point_name + ".total_perf.CG.fuelburn")
+
+    for surface in surfaces:
+        name = surface["name"]
+
+        if surf_dict["distributed_fuel_weight"]:
+            prob.model.connect("load_factor", point_name + ".coupled.load_factor", src_indices=[i])
+
+        com_name = point_name + "." + name + "_perf."
+        prob.model.connect(
+            name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+        )
+        prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+        # Connect aerodyamic mesh to coupled group mesh
+        prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+        if surf_dict["struct_weight_relief"]:
+            prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+        # Connect performance calculation variables
+        prob.model.connect(name + ".nodes", com_name + "nodes")
+        prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+        prob.model.connect(name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass")
+
+        # Connect wingbox properties to von Mises stress calcs
+        prob.model.connect(name + ".Qz", com_name + "Qz")
+        prob.model.connect(name + ".J", com_name + "J")
+        prob.model.connect(name + ".A_enc", com_name + "A_enc")
+        prob.model.connect(name + ".htop", com_name + "htop")
+        prob.model.connect(name + ".hbottom", com_name + "hbottom")
+        prob.model.connect(name + ".hfront", com_name + "hfront")
+        prob.model.connect(name + ".hrear", com_name + "hrear")
+
+        prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+        prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+prob.model.connect("alpha", "AS_point_0" + ".alpha")
+prob.model.connect("alpha_maneuver", "AS_point_1" + ".alpha")
+
+# Here we add the fuel volume constraint componenet to the model
+prob.model.add_subsystem("fuel_vol_delta", WingboxFuelVolDelta(surface=surface))
+prob.model.connect("wing.struct_setup.fuel_vols", "fuel_vol_delta.fuel_vols")
+prob.model.connect("AS_point_0.fuelburn", "fuel_vol_delta.fuelburn")
+
+if surf_dict["distributed_fuel_weight"]:
+    prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_0.coupled.wing.struct_states.fuel_vols")
+    prob.model.connect("fuel_mass", "AS_point_0.coupled.wing.struct_states.fuel_mass")
+
+    prob.model.connect("wing.struct_setup.fuel_vols", "AS_point_1.coupled.wing.struct_states.fuel_vols")
+    prob.model.connect("fuel_mass", "AS_point_1.coupled.wing.struct_states.fuel_mass")
+
+comp = om.ExecComp("fuel_diff = (fuel_mass - fuelburn) / fuelburn", units="kg")
+prob.model.add_subsystem("fuel_diff", comp, promotes_inputs=["fuel_mass"], promotes_outputs=["fuel_diff"])
+prob.model.connect("AS_point_0.fuelburn", "fuel_diff.fuelburn")
+
+
+## Use these settings if you do not have pyOptSparse or SNOPT
+prob.driver = om.ScipyOptimizeDriver()
+prob.driver.options["optimizer"] = "SLSQP"
+prob.driver.options["tol"] = 1e-8
+
+# # The following are the optimizer settings used for the EngOpt conference paper
+# # Uncomment them if you can use SNOPT
+# prob.driver = om.pyOptSparseDriver()
+# prob.driver.options['optimizer'] = "SNOPT"
+# prob.driver.opt_settings['Major optimality tolerance'] = 5e-6
+# prob.driver.opt_settings['Major feasibility tolerance'] = 1e-8
+# prob.driver.opt_settings['Major iterations limit'] = 200
+
+recorder = om.SqliteRecorder("aerostruct.db")
+prob.driver.add_recorder(recorder)
+
+# We could also just use prob.driver.recording_options['includes']=['*'] here, but for large meshes the database file becomes extremely large. So we just select the variables we need.
+prob.driver.recording_options["includes"] = [
+    "alpha",
+    "rho",
+    "v",
+    "cg",
+    "AS_point_1.cg",
+    "AS_point_0.cg",
+    "AS_point_0.coupled.wing_loads.loads",
+    "AS_point_1.coupled.wing_loads.loads",
+    "AS_point_0.coupled.wing.normals",
+    "AS_point_1.coupled.wing.normals",
+    "AS_point_0.coupled.wing.widths",
+    "AS_point_1.coupled.wing.widths",
+    "AS_point_0.coupled.aero_states.wing_sec_forces",
+    "AS_point_1.coupled.aero_states.wing_sec_forces",
+    "AS_point_0.wing_perf.CL1",
+    "AS_point_1.wing_perf.CL1",
+    "AS_point_0.coupled.wing.S_ref",
+    "AS_point_1.coupled.wing.S_ref",
+    "wing.geometry.twist",
+    "wing.mesh",
+    "wing.skin_thickness",
+    "wing.spar_thickness",
+    "wing.t_over_c",
+    "wing.structural_mass",
+    "AS_point_0.wing_perf.vonmises",
+    "AS_point_1.wing_perf.vonmises",
+    "AS_point_0.coupled.wing.def_mesh",
+    "AS_point_1.coupled.wing.def_mesh",
+]
+
+prob.driver.recording_options["record_objectives"] = True
+prob.driver.recording_options["record_constraints"] = True
+prob.driver.recording_options["record_desvars"] = True
+prob.driver.recording_options["record_inputs"] = True
+
+prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+prob.model.add_design_var("fuel_mass", lower=0.0, upper=2e5, scaler=1e-5)
+prob.model.add_design_var("alpha_maneuver", lower=-15.0, upper=15)
+
+prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+prob.model.add_constraint("AS_point_1.L_equals_W", equals=0.0)
+prob.model.add_constraint("AS_point_1.wing_perf.failure", upper=0.0)
+
+prob.model.add_constraint("fuel_vol_delta.fuel_vol_delta", lower=0.0)
+prob.model.add_constraint("fuel_diff", equals=0.0)
+
+# Set up the problem
+prob.setup()
+
+# change linear solver for aerostructural coupled adjoint
+prob.model.AS_point_0.coupled.linear_solver = om.LinearBlockGS(iprint=0, maxiter=30, use_aitken=True)
+prob.model.AS_point_1.coupled.linear_solver = om.LinearBlockGS(iprint=0, maxiter=30, use_aitken=True)
+
+# om.n2(prob)
+
+# prob.check_partials(form='central', compact_print=True)
+
+prob.run_driver()
+# prob.run_model()
+
+print("The fuel burn value is", prob["AS_point_0.fuelburn"][0], "[kg]")
+print(
+    "The wingbox mass (excluding the wing_weight_ratio) is",
+    prob["wing.structural_mass"][0] / surf_dict["wing_weight_ratio"],
+    "[kg]",
+)
diff --git a/openaerostruct/examples/run_aerostruct_uCRM_multipoint.py b/openaerostruct/examples/run_aerostruct_uCRM_multipoint.py
index 01ae10d1b..601a2601b 100644
--- a/openaerostruct/examples/run_aerostruct_uCRM_multipoint.py
+++ b/openaerostruct/examples/run_aerostruct_uCRM_multipoint.py
@@ -87,7 +87,8 @@
     # Structural values are based on aluminum 7075
     "E": 73.1e9,  # [Pa] Young's modulus
     "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-    "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+    "yield": 420.0e6,  # [Pa] yield stress
+    "safety_factor": 1.5,  # safety factor
     "mrho": 2.78e3,  # [kg/m^3] material density
     "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
     "wing_weight_ratio": 1.25,
diff --git a/openaerostruct/examples/run_scaneagle.py b/openaerostruct/examples/run_scaneagle.py
index 7d1763cee..f44b4a010 100644
--- a/openaerostruct/examples/run_scaneagle.py
+++ b/openaerostruct/examples/run_scaneagle.py
@@ -97,6 +97,7 @@
     "E": 85.0e9,
     "G": 25.0e9,
     "yield": 350.0e6,
+    "safety_factor": 1,
     "mrho": 1.6e3,
     "fem_origin": 0.35,  # normalized chordwise location of the spar
     "wing_weight_ratio": 1.0,  # multiplicative factor on the computed structural weight
diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 0237a248c..d4d3144b1 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -15,7 +15,6 @@
 from openaerostruct.structures.tube_group import TubeGroup
 from openaerostruct.structures.wingbox_group import WingboxGroup
 from openaerostruct.utils.check_surface_dict import check_surface_dict_keys
-
 import openmdao.api as om
 
 
@@ -59,7 +58,7 @@ def setup(self):
             promotes_outputs=geom_promotes_out,
         )
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             tube_promotes_input = []
             tube_promotes_output = ["A", "Iy", "Iz", "J", "radius", "thickness"]
             if "thickness_cp" in surface.keys() and connect_geom_DVs:
@@ -73,9 +72,23 @@ def setup(self):
                 promotes_inputs=tube_promotes_input,
                 promotes_outputs=tube_promotes_output,
             )
-        elif surface["fem_model_type"] == "wingbox":
+        elif (
+            surface["fem_model_type"].lower() == "wingbox"
+        ):  # connections and nomenclature remains the same for both isotropic and composite wingbox
             wingbox_promotes_in = ["mesh", "t_over_c"]
-            wingbox_promotes_out = ["A", "Iy", "Iz", "J", "Qz", "A_enc", "A_int", "htop", "hbottom", "hfront", "hrear"]
+            wingbox_promotes_out = [
+                "A",
+                "Iy",
+                "Iz",
+                "J",
+                "Qz",
+                "A_enc",
+                "A_int",
+                "htop",
+                "hbottom",
+                "hfront",
+                "hrear",
+            ]
             if "skin_thickness_cp" in surface.keys() and "spar_thickness_cp" in surface.keys():
                 wingbox_promotes_in.append("skin_thickness_cp")
                 wingbox_promotes_in.append("spar_thickness_cp")
@@ -93,7 +106,7 @@ def setup(self):
         else:
             raise NameError("Please select a valid `fem_model_type` from either `tube` or `wingbox`.")
 
-        if surface["fem_model_type"] == "wingbox":
+        if surface["fem_model_type"].lower() == "wingbox":  # same for both isotropic and composite wingbox
             promotes = ["A_int"]
         else:
             promotes = []
@@ -302,7 +315,7 @@ def setup(self):
             promotes_outputs=["CDv", "CDw", "L", "D", "CL1", "CDi", "CD", "CL", "Cl"],
         )
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.add_subsystem(
                 "struct_funcs",
                 SpatialBeamFunctionals(surface=surface),
@@ -310,7 +323,12 @@ def setup(self):
                 promotes_outputs=["thickness_intersects", "vonmises", "failure"],
             )
 
-        elif surface["fem_model_type"] == "wingbox":
+        elif surface["fem_model_type"].lower() == "wingbox":
+            if "useComposite" in surface.keys() and surface["useComposite"]:  # using the Composite Wing Box
+                promotedoutput = "tsaiwu_sr"
+            else:  # using the isotropic Wing Box
+                promotedoutput = "vonmises"
+
             self.add_subsystem(
                 "struct_funcs",
                 SpatialBeamFunctionals(surface=surface),
@@ -326,7 +344,7 @@ def setup(self):
                     "nodes",
                     "disp",
                 ],
-                promotes_outputs=["vonmises", "failure"],
+                promotes_outputs=[promotedoutput, "failure"],
             )
         else:
             raise NameError("Please select a valid `fem_model_type` from either `tube` or `wingbox`.")
diff --git a/openaerostruct/structures/compute_nodes.py b/openaerostruct/structures/compute_nodes.py
index af4a44920..0e18f6e90 100644
--- a/openaerostruct/structures/compute_nodes.py
+++ b/openaerostruct/structures/compute_nodes.py
@@ -31,7 +31,7 @@ def setup(self):
         nx = mesh.shape[0]
         ny = mesh.shape[1]
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.fem_origin = surface["fem_origin"]
         else:
             y_upper = surface["data_y_upper"]
diff --git a/openaerostruct/structures/failure_exact.py b/openaerostruct/structures/failure_exact.py
index 199047b4d..0f2bc15c7 100644
--- a/openaerostruct/structures/failure_exact.py
+++ b/openaerostruct/structures/failure_exact.py
@@ -9,13 +9,17 @@ class FailureExact(om.ExplicitComponent):
 
     Parameters
     ----------
-    vonmises[ny-1, 2] : numpy array
+    vonmises : ny-1 x 2 numpy array
         von Mises stress magnitudes for each FEM element.
+    tsaiwu_sr : ny-1 x 4 * num_plies numpy array
+        Tsai-Wu strength ratios for each FEM element (ply at each critical element).
 
     Returns
     -------
-    failure[ny-1, 2] : numpy array
-        Array of failure conditions. Positive if element has failed.
+    failure : ny-1 x num_failure_criteria array
+        Array of failure conditions. Positive if element has failed. This entity is defined for either failure criteria,
+        vonmises or tsaiwu_sr. num_failure_criteria is 2 for tube, 4 for the isotropic wingbox and 4*num_plies for the
+        composite wingbox.
 
     """
 
@@ -24,19 +28,48 @@ def initialize(self):
 
     def setup(self):
         surface = self.options["surface"]
+        self.useComposite = "useComposite" in self.options["surface"].keys() and self.options["surface"]["useComposite"]
+        if self.useComposite:
+            ply_angles = surface["ply_angles"]
+            num_plies = len(ply_angles)
 
-        if surface["fem_model_type"] == "tube":
+        if "safety_factor" in self.options["surface"].keys():
+            safety_factor = surface["safety_factor"]
+        else:
+            safety_factor = 1
+
+        if surface["fem_model_type"].lower() == "tube":
             num_failure_criteria = 2
-        elif surface["fem_model_type"] == "wingbox":
-            num_failure_criteria = 4
+
+        elif surface["fem_model_type"].lower() == "wingbox":
+            if self.useComposite:  # using the Composite wingbox
+                num_failure_criteria = 4 * num_plies  # 4 critical elements * number of plies
+                self.srlimit = 1 / safety_factor
+            else:  # using the Isotropic wingbox
+                num_failure_criteria = 4
 
         self.ny = surface["mesh"].shape[1]
-        self.sigma = surface["yield"]
 
-        self.add_input("vonmises", val=np.zeros((self.ny - 1, num_failure_criteria)), units="N/m**2")
+        self.sigma = surface["yield"] / safety_factor
+
+        if self.useComposite:  # using the Composite wingbox
+            self.add_input("tsaiwu_sr", val=np.zeros((self.ny - 1, num_failure_criteria)), units=None)
+        else:  # using the Isotropic structures
+            self.add_input("vonmises", val=np.zeros((self.ny - 1, num_failure_criteria)), units="N/m**2")
+
         self.add_output("failure", val=np.zeros((self.ny - 1, num_failure_criteria)))
 
-        self.declare_partials("failure", "vonmises", val=np.eye(((self.ny - 1) * num_failure_criteria)) / self.sigma)
+        if self.useComposite:  # using the Composite wingbox
+            self.declare_partials(
+                "failure", "tsaiwu_sr", val=np.eye(((self.ny - 1) * num_failure_criteria)) / self.srlimit
+            )
+        else:  # using the Isotropic structures
+            self.declare_partials(
+                "failure", "vonmises", val=np.eye(((self.ny - 1) * num_failure_criteria)) / self.sigma
+            )
 
     def compute(self, inputs, outputs):
-        outputs["failure"] = inputs["vonmises"] / self.sigma - 1
+        if "vonmises" in inputs:
+            outputs["failure"] = inputs["vonmises"] / self.sigma - 1
+        elif "tsaiwu_sr" in inputs:
+            outputs["failure"] = inputs["tsaiwu_sr"] / self.srlimit - 1
diff --git a/openaerostruct/structures/failure_ks.py b/openaerostruct/structures/failure_ks.py
index b7cbb9f7d..46fc5def9 100644
--- a/openaerostruct/structures/failure_ks.py
+++ b/openaerostruct/structures/failure_ks.py
@@ -21,16 +21,18 @@ class FailureKS(om.ExplicitComponent):
 
     Parameters
     ----------
-    vonmises[ny-1, 2] : numpy array
+    vonmises : ny-1 x 2 numpy array
         von Mises stress magnitudes for each FEM element.
+    tsaiwu_sr : ny-1 x 4 * num_plies numpy array
+        Tsai-Wu strength ratios for each FEM element (ply at each critical element).
 
     Returns
     -------
     failure : float
         KS aggregation quantity obtained by combining the failure criteria
         for each FEM node. Used to simplify the optimization problem by
-        reducing the number of constraints.
-
+        reducing the number of constraints. This entity is defined for either
+        failure criteria, vonmises or tsaiwu_sr.
     """
 
     def initialize(self):
@@ -39,55 +41,67 @@ def initialize(self):
 
     def setup(self):
         surface = self.options["surface"]
-        rho = self.options["rho"]
-
-        if surface["fem_model_type"] == "tube":
+        self.rho = self.options["rho"]
+
+        if "safety_factor" in self.options["surface"].keys():
+            self.safety_factor = surface["safety_factor"]
+        else:
+            self.safety_factor = 1
+
+        self.useComposite = "useComposite" in self.options["surface"].keys() and self.options["surface"]["useComposite"]
+        if self.useComposite:
+            self.num_plies = len(surface["ply_angles"])
+            self.input_name = "tsaiwu_sr"
+            self.stress_limit = 1 / self.safety_factor
+            self.stress_units = None
+        else:
+            self.input_name = "vonmises"
+            self.stress_limit = surface["yield"] / self.safety_factor
+            self.stress_units = "N/m**2"
+
+        if surface["fem_model_type"].lower() == "tube":
             num_failure_criteria = 2
-        elif surface["fem_model_type"] == "wingbox":
-            num_failure_criteria = 4
+
+        elif surface["fem_model_type"].lower() == "wingbox":
+            if self.useComposite:  # using the Composite wingbox
+                num_failure_criteria = 4 * self.num_plies  # 4 critical elements * number of plies
+            else:  # using the Isotropic wingbox
+                num_failure_criteria = 4
 
         self.ny = surface["mesh"].shape[1]
 
-        self.add_input("vonmises", val=np.zeros((self.ny - 1, num_failure_criteria)), units="N/m**2")
-        self.add_output("failure", val=0.0)
+        self.add_input(self.input_name, val=np.zeros((self.ny - 1, num_failure_criteria)), units=self.stress_units)
 
-        self.sigma = surface["yield"]
-        self.rho = rho
+        self.add_output("failure", val=0.0)
 
         self.declare_partials("*", "*")
 
     def compute(self, inputs, outputs):
-        sigma = self.sigma
-        rho = self.rho
-        vonmises = inputs["vonmises"]
+        stress_array = inputs[self.input_name]
 
-        fmax = np.max(vonmises / sigma - 1)
+        fmax = np.max(stress_array / self.stress_limit - 1)
 
         nlog, nsum, nexp = np.log, np.sum, np.exp
-        ks = 1 / rho * nlog(nsum(nexp(rho * (vonmises / sigma - 1 - fmax))))
+        ks = 1 / self.rho * nlog(nsum(nexp(self.rho * (stress_array / self.stress_limit - 1 - fmax))))
         outputs["failure"] = fmax + ks
 
     def compute_partials(self, inputs, partials):
-        vonmises = inputs["vonmises"]
-        sigma = self.sigma
-        rho = self.rho
+        stress_array = inputs[self.input_name]
 
-        # Find the location of the max stress constraint
-        fmax = np.max(vonmises / sigma - 1)
-        i, j = np.where((vonmises / sigma - 1) == fmax)
+        fmax = np.max(stress_array / self.stress_limit - 1)
+        i, j = np.where((stress_array / self.stress_limit - 1) == fmax)
         i, j = i[0], j[0]
 
-        # Set incoming seed as 1 so we simply get the jacobian entries
         ksb = 1.0
 
-        # Use results from the AD code to compute the jacobian entries
-        tempb0 = ksb / (rho * np.sum(np.exp(rho * (vonmises / sigma - fmax - 1))))
-        tempb = np.exp(rho * (vonmises / sigma - fmax - 1)) * rho * tempb0
+        tempb0 = ksb / (self.rho * np.sum(np.exp(self.rho * (stress_array / self.stress_limit - fmax - 1))))
+        tempb = np.exp(self.rho * (stress_array / self.stress_limit - fmax - 1)) * self.rho * tempb0
         fmaxb = ksb - np.sum(tempb)
 
-        # Populate the entries
-        derivs = tempb / sigma
-        derivs[i, j] += fmaxb / sigma
+        derivs = tempb / self.stress_limit
+        derivs[i, j] += fmaxb / self.stress_limit
 
-        # Reshape and save them to the jac dict
-        partials["failure", "vonmises"] = derivs.reshape(1, -1)
+        if self.useComposite:  # using the Composite wingbox
+            partials["failure", "tsaiwu_sr"] = derivs.reshape(1, -1)
+        else:  # using the Isotropic structures
+            partials["failure", "vonmises"] = derivs.reshape(1, -1)
diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index 5cd4e8d85..da1210846 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -5,6 +5,7 @@
 # from openaerostruct.structures.spar_within_wing import SparWithinWing
 from openaerostruct.structures.vonmises_tube import VonMisesTube
 from openaerostruct.structures.vonmises_wingbox import VonMisesWingbox
+from openaerostruct.structures.tsaiwu_wingbox import TsaiWuWingbox
 from openaerostruct.structures.non_intersecting_thickness import NonIntersectingThickness
 from openaerostruct.structures.failure_exact import FailureExact
 from openaerostruct.structures.failure_ks import FailureKS
@@ -26,7 +27,7 @@ def setup(self):
         #          Energy(surface=surface),
         #          promotes=['*'])
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.add_subsystem(
                 "thicknessconstraint",
                 NonIntersectingThickness(surface=surface),
@@ -40,24 +41,44 @@ def setup(self):
                 promotes_inputs=["radius", "nodes", "disp"],
                 promotes_outputs=["vonmises"],
             )
-        elif surface["fem_model_type"] == "wingbox":
-            self.add_subsystem(
-                "vonmises",
-                VonMisesWingbox(surface=surface),
-                promotes_inputs=[
-                    "Qz",
-                    "J",
-                    "A_enc",
-                    "spar_thickness",
-                    "htop",
-                    "hbottom",
-                    "hfront",
-                    "hrear",
-                    "nodes",
-                    "disp",
-                ],
-                promotes_outputs=["vonmises"],
-            )
+
+        elif surface["fem_model_type"].lower() == "wingbox":
+            if "useComposite" in surface.keys() and surface["useComposite"]:  # using the Composite wingbox
+                self.add_subsystem(
+                    "tsaiwu_sr",
+                    TsaiWuWingbox(surface=surface),
+                    promotes_inputs=[
+                        "Qz",
+                        "J",
+                        "A_enc",
+                        "spar_thickness",
+                        "htop",
+                        "hbottom",
+                        "hfront",
+                        "hrear",
+                        "nodes",
+                        "disp",
+                    ],
+                    promotes_outputs=["tsaiwu_sr"],
+                )
+            else:  # using the Isotropic wingbox
+                self.add_subsystem(
+                    "vonmises",
+                    VonMisesWingbox(surface=surface),
+                    promotes_inputs=[
+                        "Qz",
+                        "J",
+                        "A_enc",
+                        "spar_thickness",
+                        "htop",
+                        "hbottom",
+                        "hfront",
+                        "hrear",
+                        "nodes",
+                        "disp",
+                    ],
+                    promotes_outputs=["vonmises"],
+                )
         else:
             raise NameError("Please select a valid `fem_model_type` from either `tube` or `wingbox`.")
 
@@ -68,10 +89,24 @@ def setup(self):
         #          promotes=['*'])
 
         if surface["exact_failure_constraint"]:
+            if "useComposite" in surface.keys() and surface["useComposite"]:  # using the Composite wingbox
+                promotedinput = "tsaiwu_sr"
+            else:  # using the Isotropic structures
+                promotedinput = "vonmises"
+
             self.add_subsystem(
-                "failure", FailureExact(surface=surface), promotes_inputs=["vonmises"], promotes_outputs=["failure"]
+                "failure",
+                FailureExact(surface=surface),
+                promotes_inputs=[promotedinput],
+                promotes_outputs=["failure"],
             )
+
         else:
+            if "useComposite" in surface.keys() and surface["useComposite"]:  # using the Composite wingbox
+                promotedinput = "tsaiwu_sr"
+            else:  # using the Isotropic structures
+                promotedinput = "vonmises"
+
             self.add_subsystem(
-                "failure", FailureKS(surface=surface), promotes_inputs=["vonmises"], promotes_outputs=["failure"]
+                "failure", FailureKS(surface=surface), promotes_inputs=[promotedinput], promotes_outputs=["failure"]
             )
diff --git a/openaerostruct/structures/spatial_beam_setup.py b/openaerostruct/structures/spatial_beam_setup.py
index fedcfa0b7..172505bfd 100644
--- a/openaerostruct/structures/spatial_beam_setup.py
+++ b/openaerostruct/structures/spatial_beam_setup.py
@@ -40,7 +40,7 @@ def setup(self):
             promotes_outputs=["cg_location"],
         )
 
-        if surface["fem_model_type"] == "wingbox":
+        if "wingbox" in surface["fem_model_type"].lower():
             self.add_subsystem(
                 "fuel_vol",
                 WingboxFuelVol(surface=surface),
diff --git a/openaerostruct/structures/struct_groups.py b/openaerostruct/structures/struct_groups.py
index 7dce65f3f..92ec8d0a0 100644
--- a/openaerostruct/structures/struct_groups.py
+++ b/openaerostruct/structures/struct_groups.py
@@ -20,7 +20,7 @@ def setup(self):
             "geometry", Geometry(surface=surface), promotes_inputs=[], promotes_outputs=["mesh", "t_over_c"]
         )
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             tube_promotes_input = []
             tube_promotes_output = ["A", "Iy", "Iz", "J", "radius", "thickness"]
             if "thickness_cp" in surface.keys():
@@ -34,9 +34,23 @@ def setup(self):
                 promotes_inputs=tube_promotes_input,
                 promotes_outputs=tube_promotes_output,
             )
-        elif surface["fem_model_type"] == "wingbox":
+        elif (
+            surface["fem_model_type"].lower() == "wingbox"
+        ):  # connections and nomenclature remains same for both isotropic and composite wingbox
             wingbox_promotes_in = ["mesh", "t_over_c"]
-            wingbox_promotes_out = ["A", "Iy", "Iz", "J", "Qz", "A_enc", "A_int", "htop", "hbottom", "hfront", "hrear"]
+            wingbox_promotes_out = [
+                "A",
+                "Iy",
+                "Iz",
+                "J",
+                "Qz",
+                "A_enc",
+                "A_int",
+                "htop",
+                "hbottom",
+                "hfront",
+                "hrear",
+            ]
             if "skin_thickness_cp" in surface.keys() and "spar_thickness_cp" in surface.keys():
                 wingbox_promotes_in.append("skin_thickness_cp")
                 wingbox_promotes_in.append("spar_thickness_cp")
@@ -54,14 +68,16 @@ def setup(self):
         else:
             raise NameError("Please select a valid `fem_model_type` from either `tube` or `wingbox`.")
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.add_subsystem(
                 "struct_setup",
                 SpatialBeamSetup(surface=surface),
                 promotes_inputs=["mesh", "A", "Iy", "Iz", "J"],
                 promotes_outputs=["nodes", "local_stiff_transformed", "structural_mass", "cg_location", "element_mass"],
             )
-        else:
+        elif (
+            surface["fem_model_type"].lower() == "wingbox"
+        ):  # connections and nomenclature remains same for both isotropic and composite wingbox
             self.add_subsystem(
                 "struct_setup",
                 SpatialBeamSetup(surface=surface),
@@ -92,14 +108,19 @@ def setup(self):
             promotes_outputs=["disp"],
         )
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.add_subsystem(
                 "struct_funcs",
                 SpatialBeamFunctionals(surface=surface),
                 promotes_inputs=["thickness", "radius", "nodes", "disp"],
                 promotes_outputs=["thickness_intersects", "vonmises", "failure"],
             )
-        else:
+        elif surface["fem_model_type"].lower() == "wingbox":
+            if "useComposite" in surface.keys() and surface["useComposite"]:  # using the Composite wingbox
+                promotedoutput = "tsaiwu_sr"
+            else:  # using the Isotropic wingbox
+                promotedoutput = "vonmises"
+
             self.add_subsystem(
                 "struct_funcs",
                 SpatialBeamFunctionals(surface=surface),
@@ -115,5 +136,5 @@ def setup(self):
                     "hrear",
                     "nodes",
                 ],
-                promotes_outputs=["vonmises", "failure"],
+                promotes_outputs=[promotedoutput, "failure"],
             )
diff --git a/openaerostruct/structures/tsaiwu_wingbox.py b/openaerostruct/structures/tsaiwu_wingbox.py
new file mode 100644
index 000000000..6c7cacf84
--- /dev/null
+++ b/openaerostruct/structures/tsaiwu_wingbox.py
@@ -0,0 +1,235 @@
+import numpy as np
+
+import openmdao.api as om
+
+from openaerostruct.structures.utils import norm, unit, compute_lamina_transformation_matrix
+
+
+class TsaiWuWingbox(om.ExplicitComponent):
+    """Compute the Tsai-Wu failure criteria for each element, and return an array of the Strength Ratios (SR) for each ply at each element (4).
+    The Tsai-Wu failure criterion is a quadratic expression that is used to predict the failure of composite materials.
+
+    Parameters
+    ----------
+    nodes[ny, 3] : numpy array
+        Flattened array with coordinates for each FEM node.
+    disp[ny, 6] : numpy array
+        Displacements of each FEM node.
+    Qz[ny-1] : numpy array
+        First moment of area above the neutral axis parallel to the local
+        z-axis (for each wingbox segment).
+    J[ny-1] : numpy array
+        Torsion constants for each wingbox segment.
+    A_enc[ny-1] : numpy array
+        Cross-sectional enclosed area (measured using the material midlines) of
+        each wingbox segment.
+    spar_thickness[ny-1] : numpy array
+        Material thicknesses of the front and rear spars for each wingbox segment.
+    htop[ny-1] : numpy array
+        Distance to the point on the top skin that is the farthest away from
+        the local-z neutral axis (for each wingbox segment).
+    hbottom[ny-1] : numpy array
+        Distance to the point on the bottom skin that is the farthest away from
+        the local-z neutral axis (for each wingbox segment).
+    hfront[ny-1] : numpy array
+        Distance to the point on the front spar that is the farthest away from
+        the local-y neutral axis (for each wingbox segment).
+    hrear[ny-1] : numpy array
+        Distance to the point on the rear spar that is the farthest away
+        from the local-y neutral axis (for each wingbox segment).
+
+    Returns
+    -------
+    tsaiwu_sr[ny-1, 16] : numpy array
+        Tsai-Wu Strength Ratios for each FEM element (4 critical elements * number of plies).
+
+    """
+
+    def initialize(self):
+        self.options.declare("surface", types=dict)
+
+    def setup(self):
+        self.surface = surface = self.options["surface"]
+        self.ply_angles = surface["ply_angles"]
+        self.num_plies = len(self.ply_angles)
+
+        self.ny = surface["mesh"].shape[1]
+
+        self.add_input("nodes", val=np.zeros((self.ny, 3)), units="m")
+        self.add_input("disp", val=np.zeros((self.ny, 6)), units="m")
+        self.add_input("Qz", val=np.zeros((self.ny - 1)), units="m**3")
+        self.add_input("J", val=np.zeros((self.ny - 1)), units="m**4")
+        self.add_input("A_enc", val=np.zeros((self.ny - 1)), units="m**2")
+        self.add_input("spar_thickness", val=np.zeros((self.ny - 1)), units="m")
+        self.add_input("htop", val=np.zeros((self.ny - 1)), units="m")
+        self.add_input("hbottom", val=np.zeros((self.ny - 1)), units="m")
+        self.add_input("hfront", val=np.zeros((self.ny - 1)), units="m")
+        self.add_input("hrear", val=np.zeros((self.ny - 1)), units="m")
+        self.add_output("tsaiwu_sr", val=np.zeros((self.ny - 1, self.num_plies * 4)))
+
+        self.E = surface["E"]
+        self.G = surface["G"]
+
+        self.E1 = surface["E1"]
+        self.E2 = surface["E2"]
+        self.G12 = surface["G12"]
+        self.nu12 = surface["nu12"]
+        self.nu21 = self.nu12 * self.E2 / self.E1
+
+        self.sigma_c1 = surface["sigma_c1"]
+        self.sigma_t1 = surface["sigma_t1"]
+        self.sigma_c2 = surface["sigma_c2"]
+        self.sigma_t2 = surface["sigma_t2"]
+        self.sigma_12max = surface["sigma_12max"]
+
+        # sanity check: all strength values should be positive
+        if self.sigma_c1 <= 0:
+            raise ValueError("Composite material strength: sigma_c1 must be positive")
+        if self.sigma_c2 <= 0:
+            raise ValueError("Composite material strength: sigma_c2 must be positive")
+        if self.sigma_12max <= 0:
+            raise ValueError("Composite material strength: sigma_12max must be positive")
+
+        self.declare_partials("*", "*", method="cs")
+
+    def compute(self, inputs, outputs):
+        disp = inputs["disp"]
+        nodes = inputs["nodes"]
+        A_enc = inputs["A_enc"]
+        Qy = inputs["Qz"]
+        J = inputs["J"]
+        htop = inputs["htop"]
+        hbottom = inputs["hbottom"]
+        hfront = inputs["hfront"]
+        hrear = inputs["hrear"]
+        spar_thickness = inputs["spar_thickness"]
+        tsaiwu_sr = outputs["tsaiwu_sr"]
+
+        # Only use complex type for these arrays if we're using cs to check derivs
+        dtype = type(disp[0, 0])
+        T = np.zeros((3, 3), dtype=dtype)
+        x_gl = np.array([1, 0, 0], dtype=dtype)
+
+        # Define ply stiffness matrix, will use this later to compute ply stress from strain
+        Q = np.zeros((3, 3))
+        Q[0, 0] = self.E1 / (1 - self.nu12 * self.nu21)
+        Q[0, 1] = self.nu12 * self.E2 / (1 - self.nu12 * self.nu21)
+        Q[1, 0] = Q[0, 1]
+        Q[1, 1] = self.E2 / (1 - self.nu12 * self.nu21)
+        Q[2, 2] = self.G12
+
+        num_elems = self.ny - 1
+        for ielem in range(num_elems):
+            P0 = nodes[ielem, :]
+            P1 = nodes[ielem + 1, :]
+            L = norm(P1 - P0)
+
+            x_loc = unit(P1 - P0)
+            y_loc = unit(np.cross(x_loc, x_gl))
+            z_loc = unit(np.cross(x_loc, y_loc))
+
+            T[0, :] = x_loc
+            T[1, :] = y_loc
+            T[2, :] = z_loc
+
+            u0x, u0y, u0z = T.dot(disp[ielem, :3])
+            r0x, r0y, r0z = T.dot(disp[ielem, 3:])
+            u1x, u1y, u1z = T.dot(disp[ielem + 1, :3])
+            r1x, r1y, r1z = T.dot(disp[ielem + 1, 3:])
+
+            # ==============================================================================
+            # strain equations
+            # ==============================================================================
+
+            # this is strain
+            axial_strain = (u1x - u0x) / L
+
+            # this is shear strain due to torsion (note this is gamma_xy or 2*epsilon_xy)
+            torsion_shear_strain = J[ielem] / L * (r1x - r0x) / 2 / spar_thickness[ielem] / A_enc[ielem]
+
+            # this is bending strain for the top skin
+            top_bending_strain = 1.0 / (L**2) * (6 * u0y + 2 * r0z * L - 6 * u1y + 4 * r1z * L) * htop[ielem]
+
+            # this is bending strain for the bottom skin
+            bottom_bending_strain = -1.0 / (L**2) * (6 * u0y + 2 * r0z * L - 6 * u1y + 4 * r1z * L) * hbottom[ielem]
+
+            # this is bending strain for the front spar
+            front_bending_strain = -1.0 / (L**2) * (-6 * u0z + 2 * r0y * L + 6 * u1z + 4 * r1y * L) * hfront[ielem]
+
+            # this is bending strain for the rear spar
+            rear_bending_strain = 1.0 / (L**2) * (-6 * u0z + 2 * r0y * L + 6 * u1z + 4 * r1y * L) * hrear[ielem]
+
+            # shear strain due to bending
+            vertical_shear_strain = (
+                1.0
+                / (L**3)
+                * (-12 * u0y - 6 * r0z * L + 12 * u1y - 6 * r1z * L)
+                * Qy[ielem]
+                / (2 * spar_thickness[ielem])
+            )
+
+            # The strain combinations for the 4 critical points (see Fig. 4 of Chauhan 2019 OAS wingbox paper)
+            # Define the epsilon_elem array for [epsion_x, epsion_y, gamma_tau] for each critical point
+            epsilon_elem = np.zeros((4, 3), dtype=dtype)
+
+            # Critical point 0: top skin & rear spar
+            epsilon_elem[0, 0] = top_bending_strain + rear_bending_strain + axial_strain
+            epsilon_elem[0, 1] = 0
+            epsilon_elem[0, 2] = torsion_shear_strain
+
+            # Critical point 1: bottom skin & front spar
+            epsilon_elem[1, 0] = bottom_bending_strain + front_bending_strain + axial_strain
+            epsilon_elem[1, 1] = 0
+            epsilon_elem[1, 2] = torsion_shear_strain
+
+            # Critical point 2: front spar
+            epsilon_elem[2, 0] = front_bending_strain + axial_strain
+            epsilon_elem[2, 1] = 0
+            epsilon_elem[2, 2] = torsion_shear_strain - vertical_shear_strain
+
+            # Critical point 3: rear spar
+            epsilon_elem[3, 0] = rear_bending_strain + axial_strain
+            epsilon_elem[3, 1] = 0
+            epsilon_elem[3, 2] = torsion_shear_strain + vertical_shear_strain
+
+            # Define the array for ply-orientation angles:
+            ply_angles = self.ply_angles
+            num_plies = len(ply_angles)
+
+            # Convert strain from the laminate frame to ply local frame for each ply
+            epsilon_elem_ply = np.zeros((4, num_plies, 3), dtype=dtype)
+            sigma_elem_ply = np.zeros((4, num_plies, 3), dtype=dtype)
+            for point_num in range(4):
+                for ply_num in range(num_plies):
+                    lam_transorm_mat = compute_lamina_transformation_matrix(-ply_angles[ply_num])
+                    # We need to use the inverse transpose of the transformation matrix to convert strains because we
+                    # are using the engineering shear strain (gamma_xy = 2*epsilon_xy)
+                    epsilon_elem_ply[point_num, ply_num, :] = (
+                        np.linalg.inv(lam_transorm_mat).T @ epsilon_elem[point_num, :]
+                    )
+
+            # ==============================================================================
+            #  Stress and strength ratio
+            # ==============================================================================
+            # Compute stresses of each ply using strain-stress relations
+            for point_num in range(4):
+                for ply_num in range(num_plies):
+                    sigma_elem_ply[point_num, ply_num, :] = Q @ epsilon_elem_ply[point_num, ply_num, :]
+
+            # Define the constants for the Tsai-Wu Strength Ratios
+            F1 = 1 / self.sigma_t1 - 1 / self.sigma_c1
+            F11 = 1 / (self.sigma_t1 * self.sigma_c1)
+            F2 = 1 / self.sigma_t2 - 1 / self.sigma_c2
+            F22 = 1 / (self.sigma_t2 * self.sigma_c2)
+            F66 = 1 / (self.sigma_12max**2)
+
+            # Find the Tsai-Wu Strength Ratios for each ply in each element and storing them in the tsaiwu_sr array
+            for point_num in range(4):
+                for ply_num in range(num_plies):
+                    a = F1 * sigma_elem_ply[point_num, ply_num, 0] + F2 * sigma_elem_ply[point_num, ply_num, 1]
+                    b = (
+                        F11 * sigma_elem_ply[point_num, ply_num, 0] ** 2
+                        + F22 * sigma_elem_ply[point_num, ply_num, 1] ** 2
+                        + F66 * sigma_elem_ply[point_num, ply_num, 2] ** 2
+                    )
+                    tsaiwu_sr[ielem, point_num * num_plies + ply_num] = 0.5 * (a + np.sqrt(a**2 + 4 * b))
diff --git a/openaerostruct/structures/utils.py b/openaerostruct/structures/utils.py
index 216446d67..0ad6eb5b5 100644
--- a/openaerostruct/structures/utils.py
+++ b/openaerostruct/structures/utils.py
@@ -61,3 +61,110 @@ def radii(mesh, t_c=0.15):
     chords = np.sqrt(np.sum(vectors**2, axis=1))
     mean_chords = 0.5 * chords[:-1] + 0.5 * chords[1:]
     return t_c * mean_chords * 0.5
+
+
+def compute_lamina_transformation_matrix(theta):
+    """
+    Compute the stress and strain transformation matrices for a given ply angle.
+
+    This is the matrix $T$ that transforms stresses and strains from the global to the material coordinate system:
+
+    .. math::
+        \begin{bmatrix}
+        \sigma_1 \\\\
+        \sigma_2 \\\\
+        \tau_{12}
+        \end{bmatrix}
+        =
+        T
+        \begin{bmatrix}
+        \sigma_x \\\\
+        \sigma_y \\\\
+        \tau_{xy}
+        \end{bmatrix}
+
+    Parameters
+    ----------
+    theta : float
+        Angle in degrees.
+
+    Returns
+    -------
+    T : numpy array
+        Transformation matrix.
+    """
+    theta = np.deg2rad(theta)
+    c = np.cos(theta)
+    s = np.sin(theta)
+
+    T = np.zeros((3, 3))
+    T[0, 0] = c**2
+    T[0, 1] = s**2
+    T[0, 2] = 2 * s * c
+    T[1, 0] = s**2
+    T[1, 1] = c**2
+    T[1, 2] = -2 * s * c
+    T[2, 0] = -s * c
+    T[2, 1] = s * c
+    T[2, 2] = c**2 - s**2
+
+    return T
+
+
+def compute_composite_stiffness(surface):
+    """
+    Function to compute the effective E and G stiffness values for a composite material,
+    based on the ply_fractions, ply angles and individual fiber and matrix properties.
+
+    Parameters
+    ----------
+    surface : dict
+        OpenAeroStruct surface dictionary.
+    """
+    E1 = surface["E1"]
+    E2 = surface["E2"]
+    v12 = surface["nu12"]
+    G12 = surface["G12"]
+    v21 = (E2 / E1) * v12
+    ply_fractions = surface["ply_fractions"]
+    ply_angles = surface["ply_angles"]
+    num_plies = len(ply_fractions)
+
+    # check inputs
+    if len(ply_fractions) != len(ply_angles):
+        raise ValueError("Length of ply_fractions and ply_angles must be equal")
+    if sum(ply_fractions) != 1:
+        raise ValueError("Sum of ply_fractions must be 1")
+
+    # finding the Q matrix
+    Q = np.zeros((3, 3))
+    Q[0, 0] = E1 / (1 - v12 * v21)
+    Q[0, 1] = v12 * E2 / (1 - v12 * v21)
+    Q[0, 2] = 0
+    Q[1, 0] = v21 * E1 / (1 - v12 * v21)
+    Q[1, 1] = E2 / (1 - v12 * v21)
+    Q[1, 2] = 0
+    Q[2, 0] = 0
+    Q[2, 1] = 0
+    Q[2, 2] = G12
+
+    # finding the Q_bar matrix for each ply in the form of a 3D Array
+    # See https://www.efunda.com/formulae/solid_mechanics/composites/comp_lamina_arbitrary.cfm for reference
+    Q_bar = np.zeros((num_plies, 3, 3))
+    Q_bar_eff = np.zeros((3, 3))
+    for i in range(num_plies):
+        theta = ply_angles[i]
+        T = compute_lamina_transformation_matrix(theta)
+        T_inv = np.linalg.inv(T)
+        Q_bar[i] = T_inv @ Q @ T_inv.T
+        Q_bar_eff += ply_fractions[i] * Q_bar[i]
+
+    S_bar_eff = np.linalg.inv(Q_bar_eff)
+    E_eff = 1 / S_bar_eff[0, 0]
+    G_eff = 1 / S_bar_eff[2, 2]
+
+    # replacing the values in the surface dictionary
+    surface["E"] = E_eff
+    surface["G"] = G_eff
+
+    # no need to return anything as the values are updated in the surface dictionary (call by reference)
diff --git a/openaerostruct/transfer/load_transfer.py b/openaerostruct/transfer/load_transfer.py
index 9004cfa50..2d8004347 100644
--- a/openaerostruct/transfer/load_transfer.py
+++ b/openaerostruct/transfer/load_transfer.py
@@ -34,7 +34,7 @@ def setup(self):
         self.nx = nx = surface["mesh"].shape[0]
         self.ny = ny = surface["mesh"].shape[1]
 
-        if surface["fem_model_type"] == "tube":
+        if surface["fem_model_type"].lower() == "tube":
             self.fem_origin = surface["fem_origin"]
         else:
             y_upper = surface["data_y_upper"]
diff --git a/openaerostruct/utils/check_surface_dict.py b/openaerostruct/utils/check_surface_dict.py
index c3a331165..f822d10b2 100755
--- a/openaerostruct/utils/check_surface_dict.py
+++ b/openaerostruct/utils/check_surface_dict.py
@@ -43,6 +43,7 @@ def check_surface_dict_keys(surface):
         "E",
         "G",
         "yield",
+        "safety_factor",
         "mrho",
         "fem_origin",
         "wing_weight_ratio",
@@ -64,6 +65,8 @@ def check_surface_dict_keys(surface):
         "data_y_upper",
         "data_x_lower",
         "data_y_lower",
+        # tsaiwu_wingbox structure
+        "useComposite",
         # FFD
         "mx",
         "my",
@@ -80,6 +83,23 @@ def check_surface_dict_keys(surface):
         "cpanels",
         "root_section",
     ]
+    # keys that are required when useComposite is True
+    compositeInputs = [
+        "safety_factor",
+        "ply_angles",
+        "ply_fractions",
+        "E1",
+        "E2",
+        "nu12",
+        "G12",
+        "sigma_t1",
+        "sigma_c1",
+        "sigma_t2",
+        "sigma_c2",
+        "sigma_12max",
+    ]
+
+    keys_implemented = list(set(keys_implemented + compositeInputs))
 
     for key in surface.keys():
         if key not in keys_implemented:
@@ -88,3 +108,34 @@ def check_surface_dict_keys(surface):
                 category=RuntimeWarning,
                 stacklevel=2,
             )
+
+    # adding checks for using the composite failure model
+    # check1: if useComposite is True, then the following keys must be present
+    useComposite = "useComposite" in surface.keys() and surface["useComposite"]
+    if useComposite:
+        for key in compositeInputs:
+            if key not in surface.keys():
+                raise ValueError(
+                    f"{key} not found in surface dict, when `useComposite` is True, the following keys must be present: {compositeInputs}",
+                )
+
+    # check2: if useComposite is True, then 'fem_model_type' must be 'wingbox'
+    if useComposite and surface.get("fem_model_type", "") != "wingbox":
+        raise ValueError(
+            "`fem_model_type` must be 'wingbox' when `useComposite` is True",
+        )
+
+    # check3: if useComposite is True, then length of ply_angles and ply_fractions must be equal
+    if useComposite:
+        if len(surface["ply_angles"]) != len(surface["ply_fractions"]):
+            raise ValueError(
+                "Length of `ply_angles` and `ply_fractions` arrays must be equal",
+            )
+
+    # check5: if useComposite is True, then the ply fractions should add to 1
+    if useComposite:
+        plyFracSum = sum(surface["ply_fractions"])
+        if abs(plyFracSum - 1) > 1e-2:
+            raise ValueError(
+                f"Sum of `ply_fractions` ({surface['ply_fractions']}) is {plyFracSum} must be 1.",
+            )
diff --git a/openaerostruct/utils/plot_wingbox.py b/openaerostruct/utils/plot_wingbox.py
index 22aa10298..465660c21 100644
--- a/openaerostruct/utils/plot_wingbox.py
+++ b/openaerostruct/utils/plot_wingbox.py
@@ -7,7 +7,6 @@
 The usage, for example, if running a case from the `examples` directory would be `python ../utils/plot_wingbox.py aerostruct.db`.
 """
 
-
 import sys
 import numpy as np
 from openmdao.recorders.sqlite_reader import SqliteCaseReader
diff --git a/openaerostruct/utils/testing.py b/openaerostruct/utils/testing.py
index 6f2308d62..162c71022 100644
--- a/openaerostruct/utils/testing.py
+++ b/openaerostruct/utils/testing.py
@@ -153,7 +153,8 @@ def get_default_surfaces():
         # Structural values are based on aluminum 7075
         "E": 70.0e9,  # [Pa] Young's modulus of the spar
         "G": 30.0e9,  # [Pa] shear modulus of the spar
-        "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+        "yield": 500.0e6,
+        "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
         "mrho": 3.0e3,  # [kg/m^3] material density
         "fem_origin": 0.35,  # normalized chordwise location of the spar
         "wing_weight_ratio": 2.0,
@@ -204,7 +205,8 @@ def get_ground_effect_surfaces():
         # Structural values are based on aluminum 7075
         "E": 70.0e9,  # [Pa] Young's modulus of the spar
         "G": 30.0e9,  # [Pa] shear modulus of the spar
-        "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+        "yield": 500.0e6,
+        "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
         "mrho": 3.0e3,  # [kg/m^3] material density
         "fem_origin": 0.35,  # normalized chordwise location of the spar
         "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct.py b/tests/integration_tests/test_aerostruct.py
index c63a1777f..aeace9b80 100644
--- a/tests/integration_tests/test_aerostruct.py
+++ b/tests/integration_tests/test_aerostruct.py
@@ -49,7 +49,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_analysis.py b/tests/integration_tests/test_aerostruct_analysis.py
index da24d58b2..5adca0b30 100644
--- a/tests/integration_tests/test_aerostruct_analysis.py
+++ b/tests/integration_tests/test_aerostruct_analysis.py
@@ -47,7 +47,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_analysis_Sref.py b/tests/integration_tests/test_aerostruct_analysis_Sref.py
index 9daee86e4..c61d9a5aa 100644
--- a/tests/integration_tests/test_aerostruct_analysis_Sref.py
+++ b/tests/integration_tests/test_aerostruct_analysis_Sref.py
@@ -47,7 +47,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_analysis_compressible.py b/tests/integration_tests/test_aerostruct_analysis_compressible.py
index 79dc604a1..045742314 100644
--- a/tests/integration_tests/test_aerostruct_analysis_compressible.py
+++ b/tests/integration_tests/test_aerostruct_analysis_compressible.py
@@ -47,7 +47,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_engine_thrusts.py b/tests/integration_tests/test_aerostruct_engine_thrusts.py
index 54913cdcf..3e270f8dd 100644
--- a/tests/integration_tests/test_aerostruct_engine_thrusts.py
+++ b/tests/integration_tests/test_aerostruct_engine_thrusts.py
@@ -48,7 +48,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_ffd.py b/tests/integration_tests/test_aerostruct_ffd.py
index 408129c21..d56a3a8bc 100644
--- a/tests/integration_tests/test_aerostruct_ffd.py
+++ b/tests/integration_tests/test_aerostruct_ffd.py
@@ -62,7 +62,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_groundeffect.py b/tests/integration_tests/test_aerostruct_groundeffect.py
index 8b7b32ce0..1f38b5acf 100644
--- a/tests/integration_tests/test_aerostruct_groundeffect.py
+++ b/tests/integration_tests/test_aerostruct_groundeffect.py
@@ -49,7 +49,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_point_loads.py b/tests/integration_tests/test_aerostruct_point_loads.py
index 307333ac0..cc4df7721 100644
--- a/tests/integration_tests/test_aerostruct_point_loads.py
+++ b/tests/integration_tests/test_aerostruct_point_loads.py
@@ -48,7 +48,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_aerostruct_tsaiwuwingbox.py b/tests/integration_tests/test_aerostruct_tsaiwuwingbox.py
new file mode 100644
index 000000000..57dbf8121
--- /dev/null
+++ b/tests/integration_tests/test_aerostruct_tsaiwuwingbox.py
@@ -0,0 +1,227 @@
+import unittest
+import numpy as np
+
+from openaerostruct.geometry.utils import generate_mesh
+
+from openaerostruct.integration.aerostruct_groups import AerostructGeometry, AerostructPoint
+
+from openaerostruct.structures.utils import compute_composite_stiffness
+
+import openmdao.api as om
+from openmdao.utils.assert_utils import assert_near_equal
+
+# Provide coordinates for a portion of an airfoil for the wingbox cross-section as an nparray with dtype=complex (to work with the complex-step approximation for derivatives).
+# These should be for an airfoil with the chord scaled to 1.
+# We use the 10% to 60% portion of the NASA SC2-0612 airfoil for this case
+# We use the coordinates available from airfoiltools.com. Using such a large number of coordinates is not necessary.
+# The first and last x-coordinates of the upper and lower skins must be the same
+
+# fmt: off
+upper_x = np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6], dtype="complex128")
+lower_x = np.array([0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6], dtype="complex128")
+upper_y = np.array([ 0.0447,  0.046,  0.0472,  0.0484,  0.0495,  0.0505,  0.0514,  0.0523,  0.0531,  0.0538, 0.0545,  0.0551,  0.0557, 0.0563,  0.0568, 0.0573,  0.0577,  0.0581,  0.0585,  0.0588,  0.0591,  0.0593,  0.0595,  0.0597,  0.0599,  0.06,    0.0601,  0.0602,  0.0602,  0.0602,  0.0602,  0.0602,  0.0601,  0.06,    0.0599,  0.0598,  0.0596,  0.0594,  0.0592,  0.0589,  0.0586,  0.0583,  0.058,   0.0576,  0.0572,  0.0568,  0.0563,  0.0558,  0.0553,  0.0547,  0.0541], dtype="complex128")  # noqa: E201, E241
+lower_y = np.array([-0.0447, -0.046, -0.0473, -0.0485, -0.0496, -0.0506, -0.0515, -0.0524, -0.0532, -0.054, -0.0547, -0.0554, -0.056, -0.0565, -0.057, -0.0575, -0.0579, -0.0583, -0.0586, -0.0589, -0.0592, -0.0594, -0.0595, -0.0596, -0.0597, -0.0598, -0.0598, -0.0598, -0.0598, -0.0597, -0.0596, -0.0594, -0.0592, -0.0589, -0.0586, -0.0582, -0.0578, -0.0573, -0.0567, -0.0561, -0.0554, -0.0546, -0.0538, -0.0529, -0.0519, -0.0509, -0.0497, -0.0485, -0.0472, -0.0458, -0.0444], dtype="complex128")
+# fmt: on
+
+
+def setup_problem():
+    """Setup OpenMDAO problem for CRM analysis or optimization with composite wingbox model."""
+    # Create a dictionary to store options about the surface
+    mesh_dict = {
+        "num_y": 5,
+        "num_x": 3,
+        "wing_type": "CRM",
+        "symmetry": True,
+        "num_twist_cp": 6,
+        "chord_cos_spacing": 0,
+        "span_cos_spacing": 0,
+    }
+
+    mesh, _ = generate_mesh(mesh_dict)
+
+    surf_dict = {
+        # Wing definition
+        "name": "wing",  # name of the surface
+        "symmetry": True,  # if true, model one half of wing
+        # reflected across the plane y = 0
+        "S_ref_type": "wetted",  # how we compute the wing area, can be 'wetted' or 'projected'
+        "fem_model_type": "wingbox",
+        "spar_thickness_cp": np.array([0.004, 0.005, 0.005, 0.008, 0.008, 0.01]),  # [m]
+        "skin_thickness_cp": np.array([0.005, 0.01, 0.015, 0.020, 0.025, 0.026]),
+        "twist_cp": np.array([4.0, 5.0, 8.0, 8.0, 8.0, 9.0]),
+        "span": 58,  # [m] wingspan
+        "mesh": mesh,
+        "data_x_upper": upper_x,
+        "data_x_lower": lower_x,
+        "data_y_upper": upper_y,
+        "data_y_lower": lower_y,
+        # Aerodynamic performance of the lifting surface at
+        # an angle of attack of 0 (alpha=0).
+        # These CL0 and CD0 values are added to the CL and CD
+        # obtained from aerodynamic analysis of the surface to get
+        # the total CL and CD.
+        # These CL0 and CD0 values do not vary wrt alpha.
+        "CL0": 0.0,  # CL of the surface at alpha=0
+        "CD0": 0.0078,  # CD of the surface at alpha=0
+        # Airfoil properties for viscous drag calculation
+        "k_lam": 0.05,  # percentage of chord with laminar
+        # flow, used for viscous drag
+        "t_over_c_cp": np.array([0.08, 0.08, 0.08, 0.10, 0.10, 0.08]),
+        "original_wingbox_airfoil_t_over_c": 0.12,
+        "c_max_t": 0.38,  # chordwise location of maximum thickness
+        "with_viscous": True,
+        "with_wave": True,  # if true, compute wave drag
+        "wing_weight_ratio": 1.25,
+        "struct_weight_relief": True,  # True to add the weight of the structure to the loads on the structure
+        "distributed_fuel_weight": False,
+        "exact_failure_constraint": False,  # if false, use KS function
+        "Wf_reserve": 15000.0,  # [kg] reserve fuel mass
+        # Composite material parameters
+        "mrho": 1550,  # [kg/m^3] CFRP density
+        "useComposite": True,
+        "safety_factor": 1.5,
+        "ply_angles": [0, 45, -45, 90],
+        "ply_fractions": [0.10, 0.25, 0.25, 0.40],
+        "E1": 117.7e9,
+        "E2": 9.7e9,
+        "nu12": 0.35,
+        "G12": 4.8e9,
+        "sigma_t1": 1648.0e6,
+        "sigma_c1": 1034.0e6,
+        "sigma_t2": 64.0e6,
+        "sigma_c2": 228.0e6,
+        "sigma_12max": 71.0e6,
+    }
+
+    # Compute effective E and G for composite material
+    compute_composite_stiffness(surf_dict)
+
+    surfaces = [surf_dict]
+
+    # Create the problem and assign the model group
+    prob = om.Problem()
+
+    # Add problem information as an independent variables component
+    indep_var_comp = om.IndepVarComp()
+    indep_var_comp.add_output("v", val=0.85 * 295.07, units="m/s")
+    indep_var_comp.add_output("alpha", val=0.0, units="deg")
+    indep_var_comp.add_output("Mach_number", val=0.85)
+    indep_var_comp.add_output("re", val=0.348 * 295.07 * 0.85 * 1.0 / (1.43 * 1e-5), units="1/m")
+    indep_var_comp.add_output("rho", val=0.348, units="kg/m**3")
+    indep_var_comp.add_output("CT", val=0.53 / 3600, units="1/s")
+    indep_var_comp.add_output("R", val=14.307e6, units="m")
+    indep_var_comp.add_output("W0", val=148000 + surf_dict["Wf_reserve"], units="kg")
+    indep_var_comp.add_output("speed_of_sound", val=295.07, units="m/s")
+    indep_var_comp.add_output("load_factor", val=1.0)
+    indep_var_comp.add_output("empty_cg", val=np.zeros((3)), units="m")
+
+    prob.model.add_subsystem("prob_vars", indep_var_comp, promotes=["*"])
+
+    # Loop over each surface in the surfaces list
+    for surface in surfaces:
+        # Get the surface name and create a group to contain components
+        # only for this surface
+        name = surface["name"]
+
+        aerostruct_group = AerostructGeometry(surface=surface)
+
+        # Add tmp_group to the problem with the name of the surface.
+        prob.model.add_subsystem(name, aerostruct_group)
+
+    # Loop through and add a certain number of aero points
+    for i in range(1):
+        point_name = "AS_point_{}".format(i)
+        # Connect the parameters within the model for each aero point
+
+        # Create the aero point group and add it to the model
+        AS_point = AerostructPoint(surfaces=surfaces)
+
+        prob.model.add_subsystem(point_name, AS_point)
+
+        # Connect flow properties to the analysis point
+        prob.model.connect("v", point_name + ".v")
+        prob.model.connect("alpha", point_name + ".alpha")
+        prob.model.connect("Mach_number", point_name + ".Mach_number")
+        prob.model.connect("re", point_name + ".re")
+        prob.model.connect("rho", point_name + ".rho")
+        prob.model.connect("CT", point_name + ".CT")
+        prob.model.connect("R", point_name + ".R")
+        prob.model.connect("W0", point_name + ".W0")
+        prob.model.connect("speed_of_sound", point_name + ".speed_of_sound")
+        prob.model.connect("empty_cg", point_name + ".empty_cg")
+        prob.model.connect("load_factor", point_name + ".load_factor")
+
+        for _surface in surfaces:
+            com_name = point_name + "." + name + "_perf."
+            prob.model.connect(
+                name + ".local_stiff_transformed", point_name + ".coupled." + name + ".local_stiff_transformed"
+            )
+            prob.model.connect(name + ".nodes", point_name + ".coupled." + name + ".nodes")
+
+            # Connect aerodyamic mesh to coupled group mesh
+            prob.model.connect(name + ".mesh", point_name + ".coupled." + name + ".mesh")
+            prob.model.connect(name + ".element_mass", point_name + ".coupled." + name + ".element_mass")
+
+            # Connect performance calculation variables
+            prob.model.connect(name + ".nodes", com_name + "nodes")
+            prob.model.connect(name + ".cg_location", point_name + "." + "total_perf." + name + "_cg_location")
+            prob.model.connect(name + ".structural_mass", point_name + "." + "total_perf." + name + "_structural_mass")
+
+            # Connect wingbox properties to von Mises stress calcs
+            prob.model.connect(name + ".Qz", com_name + "Qz")
+            prob.model.connect(name + ".J", com_name + "J")
+            prob.model.connect(name + ".A_enc", com_name + "A_enc")
+            prob.model.connect(name + ".htop", com_name + "htop")
+            prob.model.connect(name + ".hbottom", com_name + "hbottom")
+            prob.model.connect(name + ".hfront", com_name + "hfront")
+            prob.model.connect(name + ".hrear", com_name + "hrear")
+
+            prob.model.connect(name + ".spar_thickness", com_name + "spar_thickness")
+            prob.model.connect(name + ".t_over_c", com_name + "t_over_c")
+
+    prob.model.add_objective("AS_point_0.fuelburn", scaler=1e-5)
+
+    prob.model.add_design_var("wing.twist_cp", lower=-15.0, upper=15.0, scaler=0.1)
+    prob.model.add_design_var("wing.spar_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+    prob.model.add_design_var("wing.skin_thickness_cp", lower=0.003, upper=0.1, scaler=1e2)
+    prob.model.add_design_var("wing.geometry.t_over_c_cp", lower=0.07, upper=0.2, scaler=10.0)
+    prob.model.add_design_var("wing.geometry.span", lower=55.0, upper=60.0, scaler=2e-2)
+
+    prob.model.add_constraint("AS_point_0.CL", equals=0.5)
+    prob.model.add_constraint("AS_point_0.wing_perf.failure", upper=0.0)
+
+    prob.driver = om.ScipyOptimizeDriver()
+    prob.driver.options["optimizer"] = "SLSQP"
+    prob.driver.options["tol"] = 1e-6
+
+    # Set up the problem
+    prob.setup()
+
+    # suppress AS solver output
+    prob.model.AS_point_0.coupled.nonlinear_solver.options["iprint"] = 0
+
+    return prob
+
+
+class Test(unittest.TestCase):
+    def test_analysis(self):
+        prob = setup_problem()
+        prob.run_model()
+
+        assert_near_equal(prob.get_val("AS_point_0.fuelburn", "kg"), 82966.91616709, 1e-5)
+        assert_near_equal(prob.get_val("wing.structural_mass", "kg"), 16350.358583141326, 1e-5)
+        assert_near_equal(prob.get_val("AS_point_0.wing_perf.tsaiwu_sr")[0, 0], 0.77079144, 1e-5)
+        assert_near_equal(prob.get_val("AS_point_0.wing_perf.failure"), 0.81973662, 1e-5)
+
+    def test_optimization(self):
+        prob = setup_problem()
+        prob.run_driver()
+
+        assert_near_equal(prob.get_val("AS_point_0.fuelburn", "kg"), 82194.24094301, 1e-3)
+        assert_near_equal(prob.get_val("wing.structural_mass", "kg"), 22896.21787536, 1e-3)
+        assert_near_equal(prob.get_val("AS_point_0.wing_perf.tsaiwu_sr")[0, 0], 0.4258275682134, 1e-3)
+        assert_near_equal(prob.get_val("AS_point_0.wing_perf.failure"), 0, 1e-3)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py b/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
index 38427937c..205732cb0 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_+weight_analysis.py
@@ -291,7 +291,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_aerostruct_wingbox_analysis.py b/tests/integration_tests/test_aerostruct_wingbox_analysis.py
index f098605b6..d4799c1e4 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_analysis.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_analysis.py
@@ -291,7 +291,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py b/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
index 4a15737e3..5e460c326 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_fuel_vol_constraint_opt.py
@@ -296,7 +296,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_aerostruct_wingbox_opt.py b/tests/integration_tests/test_aerostruct_wingbox_opt.py
index da3272945..401f1f073 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_opt.py
@@ -291,7 +291,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py b/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
index 8368ea880..b0a1983a8 100644
--- a/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
+++ b/tests/integration_tests/test_aerostruct_wingbox_wave_fuel_vol_constraint_opt.py
@@ -297,7 +297,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_morphing_aerostruct.py b/tests/integration_tests/test_morphing_aerostruct.py
index e248a7b5c..e7d38f90a 100644
--- a/tests/integration_tests/test_morphing_aerostruct.py
+++ b/tests/integration_tests/test_morphing_aerostruct.py
@@ -55,7 +55,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_multipoint_parallel.py b/tests/integration_tests/test_multipoint_parallel.py
index 17c3c118e..2df389bd0 100644
--- a/tests/integration_tests/test_multipoint_parallel.py
+++ b/tests/integration_tests/test_multipoint_parallel.py
@@ -111,7 +111,8 @@ def test_multipoint_MPI(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             "wing_weight_ratio": 1.25,
diff --git a/tests/integration_tests/test_multipoint_wingbox_aerostruct.py b/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
index 8baed940d..d42ac81f0 100644
--- a/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
+++ b/tests/integration_tests/test_multipoint_wingbox_aerostruct.py
@@ -297,7 +297,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_multipoint_wingbox_derivs.py b/tests/integration_tests/test_multipoint_wingbox_derivs.py
index 0bae60c03..04d84313d 100644
--- a/tests/integration_tests/test_multipoint_wingbox_derivs.py
+++ b/tests/integration_tests/test_multipoint_wingbox_derivs.py
@@ -295,7 +295,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_scaneagle.py b/tests/integration_tests/test_scaneagle.py
index 005d24981..f9c454786 100644
--- a/tests/integration_tests/test_scaneagle.py
+++ b/tests/integration_tests/test_scaneagle.py
@@ -91,6 +91,7 @@ def setUp(self):
             "E": 85.0e9,
             "G": 25.0e9,
             "yield": 350.0e6,
+            "safety_factor": 1,
             "mrho": 1.6e3,
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 1.0,  # multiplicative factor on the computed structural weight
diff --git a/tests/integration_tests/test_simple_rect_AS.py b/tests/integration_tests/test_simple_rect_AS.py
index 01aabe491..f7cfed861 100644
--- a/tests/integration_tests/test_simple_rect_AS.py
+++ b/tests/integration_tests/test_simple_rect_AS.py
@@ -49,7 +49,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 2.0,
diff --git a/tests/integration_tests/test_struct.py b/tests/integration_tests/test_struct.py
index 30c289376..a00fe4d3a 100644
--- a/tests/integration_tests/test_struct.py
+++ b/tests/integration_tests/test_struct.py
@@ -27,7 +27,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_struct_analysis.py b/tests/integration_tests/test_struct_analysis.py
index 33f93c435..56a5541b4 100644
--- a/tests/integration_tests/test_struct_analysis.py
+++ b/tests/integration_tests/test_struct_analysis.py
@@ -26,7 +26,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_struct_analysis_2g.py b/tests/integration_tests/test_struct_analysis_2g.py
index 6bf220d10..c409c4bec 100644
--- a/tests/integration_tests/test_struct_analysis_2g.py
+++ b/tests/integration_tests/test_struct_analysis_2g.py
@@ -25,7 +25,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_struct_engine_thrusts.py b/tests/integration_tests/test_struct_engine_thrusts.py
index 283b2eae4..5e039903c 100644
--- a/tests/integration_tests/test_struct_engine_thrusts.py
+++ b/tests/integration_tests/test_struct_engine_thrusts.py
@@ -25,7 +25,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.5,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
@@ -83,7 +84,8 @@ def test_multiple_masses(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.5,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_struct_no_loads.py b/tests/integration_tests/test_struct_no_loads.py
index 9d680d672..30d5e896b 100644
--- a/tests/integration_tests/test_struct_no_loads.py
+++ b/tests/integration_tests/test_struct_no_loads.py
@@ -25,7 +25,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_struct_point_masses.py b/tests/integration_tests/test_struct_point_masses.py
index eb051a730..ef67cad31 100644
--- a/tests/integration_tests/test_struct_point_masses.py
+++ b/tests/integration_tests/test_struct_point_masses.py
@@ -25,7 +25,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.5,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
@@ -83,7 +84,8 @@ def test_multiple_masses(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.5,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_v1_aerostruct_analysis.py b/tests/integration_tests/test_v1_aerostruct_analysis.py
index d571d2520..03cb8b723 100644
--- a/tests/integration_tests/test_v1_aerostruct_analysis.py
+++ b/tests/integration_tests/test_v1_aerostruct_analysis.py
@@ -54,7 +54,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 1.0,
diff --git a/tests/integration_tests/test_v1_aerostruct_opt.py b/tests/integration_tests/test_v1_aerostruct_opt.py
index 582dfa246..fb9671847 100644
--- a/tests/integration_tests/test_v1_aerostruct_opt.py
+++ b/tests/integration_tests/test_v1_aerostruct_opt.py
@@ -54,7 +54,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "wing_weight_ratio": 1.0,
diff --git a/tests/integration_tests/test_v1_struct_analysis.py b/tests/integration_tests/test_v1_struct_analysis.py
index ff8d49e4c..81eb63c43 100644
--- a/tests/integration_tests/test_v1_struct_analysis.py
+++ b/tests/integration_tests/test_v1_struct_analysis.py
@@ -33,7 +33,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_v1_struct_opt.py b/tests/integration_tests/test_v1_struct_opt.py
index e3c169094..52c78542e 100644
--- a/tests/integration_tests/test_v1_struct_opt.py
+++ b/tests/integration_tests/test_v1_struct_opt.py
@@ -33,7 +33,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 70.0e9,  # [Pa] Young's modulus of the spar
             "G": 30.0e9,  # [Pa] shear modulus of the spar
-            "yield": 500.0e6 / 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
+            "yield": 500.0e6,
+            "safety_factor": 2.5,  # [Pa] yield stress divided by 2.5 for limiting case
             "mrho": 3.0e3,  # [kg/m^3] material density
             "fem_origin": 0.35,  # normalized chordwise location of the spar
             "t_over_c_cp": np.array([0.15]),  # maximum airfoil thickness
diff --git a/tests/integration_tests/test_wingbox_analysis.py b/tests/integration_tests/test_wingbox_analysis.py
index 07c9172f3..55b9800b7 100644
--- a/tests/integration_tests/test_wingbox_analysis.py
+++ b/tests/integration_tests/test_wingbox_analysis.py
@@ -273,7 +273,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_wingbox_derivs.py b/tests/integration_tests/test_wingbox_derivs.py
index 71a5b09dd..d3db0529e 100644
--- a/tests/integration_tests/test_wingbox_derivs.py
+++ b/tests/integration_tests/test_wingbox_derivs.py
@@ -292,7 +292,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/integration_tests/test_wingbox_distributed_fuel.py b/tests/integration_tests/test_wingbox_distributed_fuel.py
index c29034b7b..85baf45db 100644
--- a/tests/integration_tests/test_wingbox_distributed_fuel.py
+++ b/tests/integration_tests/test_wingbox_distributed_fuel.py
@@ -296,7 +296,8 @@ def test(self):
             # Structural values are based on aluminum 7075
             "E": 73.1e9,  # [Pa] Young's modulus
             "G": (73.1e9 / 2 / 1.33),  # [Pa] shear modulus (calculated using E and the Poisson's ratio here)
-            "yield": (420.0e6 / 1.5),  # [Pa] allowable yield stress
+            "yield": 420.0e6,  # [Pa] yield stress
+            "safety_factor": 1.5,  # safety factor
             "mrho": 2.78e3,  # [kg/m^3] material density
             "strength_factor_for_upper_skin": 1.0,  # the yield stress is multiplied by this factor for the upper skin
             # 'fem_origin' : 0.35,    # normalized chordwise location of the spar
diff --git a/tests/structures_tests/test_composite_equivalent_stiffness.py b/tests/structures_tests/test_composite_equivalent_stiffness.py
new file mode 100644
index 000000000..e134327dd
--- /dev/null
+++ b/tests/structures_tests/test_composite_equivalent_stiffness.py
@@ -0,0 +1,56 @@
+"""Test the utility function to compute the composite's equivalent stiffness."""
+
+import unittest
+
+from openmdao.utils.assert_utils import assert_near_equal
+from openaerostruct.structures.utils import compute_composite_stiffness
+
+
+class TestCompositeEquivalentStiffness(unittest.TestCase):
+    """Test the effective stiffness computation for an isotropic material."""
+
+    def test(self):
+        # isotropic material stiffness values
+        E = 70.0e9
+        nu = 0.33
+        G = E / (2 * (1 + nu))
+
+        # setup OAS surface dictionary for the composite laminate
+        surf_dict = {
+            "ply_fractions": [0.25, 0.25, 0.25, 0.25],
+            "ply_angles": [0, 45, -45, 90],
+            "E1": E,
+            "E2": E,
+            "nu12": nu,
+            "G12": G,
+        }
+
+        # compute the effective stiffness
+        compute_composite_stiffness(surf_dict)
+        E_eff = surf_dict["E"]
+        G_eff = surf_dict["G"]
+
+        # make sure the results are close to the expected values
+        assert_near_equal(E_eff, E, 1e-6)
+        assert_near_equal(G_eff, G, 1e-6)
+
+        # another test with a different setup
+        surf_dict = {
+            "ply_fractions": [0.1, 0.2, 0.3, 0.25, 0.15],
+            "ply_angles": [12, -20, 27, 99, -5],
+            "E1": E,
+            "E2": E,
+            "nu12": nu,
+            "G12": G,
+        }
+        compute_composite_stiffness(surf_dict)
+        E_eff = surf_dict["E"]
+        G_eff = surf_dict["G"]
+
+        # make sure the results are close to the expected values
+        assert_near_equal(E_eff, E, 1e-6)
+        assert_near_equal(G_eff, G, 1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 6f37fe30060cfc8807b2a93e625a185d4d632280 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 8 Oct 2025 23:31:35 -0400
Subject: [PATCH 23/30] fix local buckling for composite

---
 .../structures/spatial_beam_functionals.py    | 31 ++++++++++++++++---
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/openaerostruct/structures/spatial_beam_functionals.py b/openaerostruct/structures/spatial_beam_functionals.py
index e86079098..f35613a88 100644
--- a/openaerostruct/structures/spatial_beam_functionals.py
+++ b/openaerostruct/structures/spatial_beam_functionals.py
@@ -114,6 +114,29 @@ def setup(self):
 
         # compute panel local buckling failure
         if "panel_buckling" in surface and surface["panel_buckling"]:
+            if "useComposite" in surface.keys() and surface["useComposite"]:
+                # need to use the von Mises component to compute skin and spar stresses
+                stress_comp = "stress"
+                self.add_subsystem(
+                    "stress",
+                    VonMisesWingbox(surface=surface),
+                    promotes_inputs=[
+                        "Qz",
+                        "J",
+                        "A_enc",
+                        "spar_thickness",
+                        "htop",
+                        "hbottom",
+                        "hfront",
+                        "hrear",
+                        "nodes",
+                        "disp",
+                    ],
+                )
+            else:
+                # reuse the existing vonmises component
+                stress_comp = "vonmises"
+
             # skin panel buckling and spar shear buckling
             self.add_subsystem(
                 "local_buckling",
@@ -121,7 +144,7 @@ def setup(self):
                 promotes_inputs=["skin_thickness", "spar_thickness", "t_over_c", "fem_chords"],
                 promotes_outputs=["failure_local_buckling"]
             )
-            self.connect("vonmises.upper_skin_comp_stress", "local_buckling.upper_skin_comp_stress")
-            self.connect("vonmises.lower_skin_comp_stress", "local_buckling.lower_skin_comp_stress")
-            self.connect("vonmises.front_spar_shear_stress", "local_buckling.front_spar_shear_stress")
-            self.connect("vonmises.rear_spar_shear_stress", "local_buckling.rear_spar_shear_stress")
+            self.connect(f"{stress_comp}.upper_skin_comp_stress", "local_buckling.upper_skin_comp_stress")
+            self.connect(f"{stress_comp}.lower_skin_comp_stress", "local_buckling.lower_skin_comp_stress")
+            self.connect(f"{stress_comp}.front_spar_shear_stress", "local_buckling.front_spar_shear_stress")
+            self.connect(f"{stress_comp}.rear_spar_shear_stress", "local_buckling.rear_spar_shear_stress")

From fc21057e149c0d05925e65d801d5170119254cab Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Fri, 10 Oct 2025 00:28:36 -0400
Subject: [PATCH 24/30] mute debug print

---
 openaerostruct/structures/fem_strut_braced.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index b3c3526a2..2ed7bed88 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -228,7 +228,7 @@ def setup(self):
 
             # partials of joint constraint residuals w.r.t. displacement
             joint_idx = get_joint_idx_from_y(surface, wing_strut_joint_y)
-            print(f'Wing-strut joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+            # print(f'Wing-strut joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
             rows, cols = _joint_rows_cols(wing_strut_joint_type, surface, joint_idx)
             if i == 0:
                 vals = np.ones(n_con_ws) * 1e9
@@ -276,7 +276,7 @@ def setup(self):
                     joint_idx = get_joint_idx_from_y(surface, wing_jury_joint_y)
                 elif name == "jury":
                     joint_idx = 0  # jury index starts from 0 at the wing-jury joint
-                print(f'Wing-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+                # print(f'Wing-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
                 rows, cols = _joint_rows_cols("rigid", surface, joint_idx)
                 if i == 0:
                     vals = np.ones(n_con_wj) * 1e9
@@ -322,7 +322,7 @@ def setup(self):
                     joint_idx = get_joint_idx_from_y(surface, strut_jury_joint_y)
                 elif name == "jury":
                     joint_idx = surface["mesh"].shape[1] - 1  # last index of jury surface
-                print(f'Strut-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
+                # print(f'Strut-jury joint ({surface["name"]}): joint y = {surface["mesh"][0, joint_idx, 1]} and joint index = {joint_idx}')
                 rows, cols = _joint_rows_cols("rigid", surface, joint_idx)
                 if i == 0:
                     vals = np.ones(n_con_sj) * 1e9

From 6ab77d31e583f6225e9988ead1d3e540ff735a14 Mon Sep 17 00:00:00 2001
From: Shugo Kaneko <49300827+kanekosh@users.noreply.github.com>
Date: Wed, 29 Oct 2025 20:53:13 -0400
Subject: [PATCH 25/30] Truss braced FEM bugfix for Windows OS (#4)

* add debug print

* deepcopy?

* remove debug print
---
 openaerostruct/structures/fem_strut_braced.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/openaerostruct/structures/fem_strut_braced.py b/openaerostruct/structures/fem_strut_braced.py
index 2ed7bed88..7b06ff173 100644
--- a/openaerostruct/structures/fem_strut_braced.py
+++ b/openaerostruct/structures/fem_strut_braced.py
@@ -191,7 +191,7 @@ def setup(self):
 
             # Set up the derivatives.
             row_col = np.arange(full_size, dtype="int")
-            self.declare_partials(f"disp_aug_{name}", f"forces_{name}", val=np.full(full_size, -1.0), rows=row_col, cols=row_col)
+            self.declare_partials(f"disp_aug_{name}", f"forces_{name}", val=np.full(full_size, -1.0), rows=row_col.copy(), cols=row_col.copy())
 
             # The derivative of residual wrt displacements is the stiffness matrix K. We can use the
             # sparsity pattern here and when constucting the sparse matrix, so save rows and cols.
@@ -203,10 +203,10 @@ def setup(self):
             k_rows.append(rows)
             k_cols.append(cols)
             self.num_k_data.append(len(rows))
-            self.declare_partials(of=f"disp_aug_{name}", wrt=f"disp_aug_{name}", rows=vec_rows, cols=vec_cols)
+            self.declare_partials(of=f"disp_aug_{name}", wrt=f"disp_aug_{name}", rows=vec_rows.copy(), cols=vec_cols.copy())
 
             rows, cols = get_drdK_sparsity_pattern(ny)
-            self.declare_partials(f"disp_aug_{name}", f"local_stiff_transformed_{name}", rows=rows, cols=cols)
+            self.declare_partials(f"disp_aug_{name}", f"local_stiff_transformed_{name}", rows=rows.copy(), cols=cols.copy())
 
         # --- wing-strut joint constraints (coupling terms between two surfaces) ---
         # list of all joing Lagrange multipliers (will use later)
@@ -234,10 +234,11 @@ def setup(self):
                 vals = np.ones(n_con_ws) * 1e9
             else:
                 vals = np.ones(n_con_ws) * -1e9
-            self.declare_partials("joint_Lag_wing_strut", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+            
+            self.declare_partials("joint_Lag_wing_strut", f"disp_aug_{name}", rows=rows.copy(), cols=cols.copy(), val=vals.copy())
 
             # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
-            self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_strut", rows=cols, cols=rows, val=vals)
+            self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_strut", rows=cols.copy(), cols=rows.copy(), val=vals.copy())
 
             # rows/cols in the global K matrix (bottom of the matrix)
             rows += sum(self.size)
@@ -282,10 +283,10 @@ def setup(self):
                     vals = np.ones(n_con_wj) * 1e9
                 else:
                     vals = np.ones(n_con_wj) * -1e9
-                self.declare_partials("joint_Lag_wing_jury", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+                self.declare_partials("joint_Lag_wing_jury", f"disp_aug_{name}", rows=rows.copy(), cols=cols.copy(), val=vals.copy())
 
                 # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
-                self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_jury", rows=cols, cols=rows, val=vals)
+                self.declare_partials(f"disp_aug_{name}", "joint_Lag_wing_jury", rows=cols.copy(), cols=rows.copy(), val=vals.copy())
 
                 # append these entries to the global K matrix
                 rows += self.total_size
@@ -328,10 +329,10 @@ def setup(self):
                     vals = np.ones(n_con_sj) * 1e9
                 else:
                     vals = np.ones(n_con_sj) * -1e9
-                self.declare_partials("joint_Lag_strut_jury", f"disp_aug_{name}", rows=rows, cols=cols, val=vals)
+                self.declare_partials("joint_Lag_strut_jury", f"disp_aug_{name}", rows=rows.copy(), cols=cols.copy(), val=vals.copy())
 
                 # partials of FEM residuals (r = Ku - f) w.r.t. joint Lagrange multipliers: transpose of above
-                self.declare_partials(f"disp_aug_{name}", "joint_Lag_strut_jury", rows=cols, cols=rows, val=vals)
+                self.declare_partials(f"disp_aug_{name}", "joint_Lag_strut_jury", rows=cols.copy(), cols=rows.copy(), val=vals.copy())
 
                 # append these entries to the bottom of the global K matrix (and the transpose to the right)
                 rows += self.total_size

From 23c698533fb5a0c5323f192dfbe1cb857887a6ea Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Fri, 31 Oct 2025 00:27:50 -0400
Subject: [PATCH 26/30] make CD0 OM variable so it can be computed upstream

---
 openaerostruct/aerodynamics/functionals.py | 2 +-
 openaerostruct/aerodynamics/total_drag.py  | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/openaerostruct/aerodynamics/functionals.py b/openaerostruct/aerodynamics/functionals.py
index 98ff29048..c4ac32a02 100644
--- a/openaerostruct/aerodynamics/functionals.py
+++ b/openaerostruct/aerodynamics/functionals.py
@@ -57,5 +57,5 @@ def setup(self):
         )
 
         self.add_subsystem(
-            "CD", TotalDrag(surface=surface), promotes_inputs=["CDv", "CDi", "CDw"], promotes_outputs=["CD"]
+            "CD", TotalDrag(surface=surface), promotes_inputs=["CDv", "CDi", "CDw", "CD0"], promotes_outputs=["CD"]
         )
diff --git a/openaerostruct/aerodynamics/total_drag.py b/openaerostruct/aerodynamics/total_drag.py
index 9b5e3ff63..c509e33f0 100644
--- a/openaerostruct/aerodynamics/total_drag.py
+++ b/openaerostruct/aerodynamics/total_drag.py
@@ -26,14 +26,14 @@ def setup(self):
         self.add_input("CDi", val=1.0)
         self.add_input("CDv", val=1.0)
         self.add_input("CDw", val=1.0)
+        self.add_input("CD0", val=surface["CD0"])
 
         self.add_output("CD", val=1.0, tags=["mphys_result"])
 
-        self.CD0 = surface["CD0"]
-
         self.declare_partials("CD", "CDi", val=1.0)
         self.declare_partials("CD", "CDv", val=1.0)
         self.declare_partials("CD", "CDw", val=1.0)
+        self.declare_partials("CD", "CD0", val=1.0)
 
     def compute(self, inputs, outputs):
-        outputs["CD"] = inputs["CDi"] + inputs["CDv"] + inputs["CDw"] + self.CD0
+        outputs["CD"] = inputs["CDi"] + inputs["CDv"] + inputs["CDw"] + inputs["CD0"]

From c2558d79bcada69bec1ced998ed9e3a8be2db574 Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Fri, 7 Nov 2025 00:35:22 -0500
Subject: [PATCH 27/30] add climb Breguet fuel burn

---
 openaerostruct/functionals/breguet_range.py   | 142 +++++++++++++++---
 .../functionals/total_performance.py          |  25 ++-
 .../integration/aerostruct_groups.py          |  37 +++--
 3 files changed, 160 insertions(+), 44 deletions(-)

diff --git a/openaerostruct/functionals/breguet_range.py b/openaerostruct/functionals/breguet_range.py
index 505a94ec8..d5e27e9cd 100644
--- a/openaerostruct/functionals/breguet_range.py
+++ b/openaerostruct/functionals/breguet_range.py
@@ -26,11 +26,9 @@ class BreguetRange(om.ExplicitComponent):
     Mach_number : float
         The Mach number of the aircraft at the specified flight condition.
     W0 : float
-        The operating empty weight of the aircraft, without fuel or structural
-        mass. Supplied in kg despite being a 'weight' due to convention.
-    load_factor : float
-        Multiplicative factor on gravity. 1.0 is normal flight; 2.5 would be
-        for a 2.5g manuever.
+        The operating empty weight (OEW) - wing structural mass + payload + reserve fuel
+        I.e. this is the landing gross mass, ignoring the descent and landing fuel burn.
+        Supplied in kg despite being a 'weight' due to convention.
     _structural_mass : float
         Weight of a single lifting surface's structural spar.
 
@@ -55,9 +53,10 @@ def setup(self):
         self.add_input("speed_of_sound", val=100.0, units="m/s")
         self.add_input("R", val=3000.0, units="m")
         self.add_input("Mach_number", val=1.2)
-        self.add_input("W0", val=200.0, units="kg")
+        self.add_input("W0", val=200.0, units="kg", desc="payload + OEW - surface str. mass + reserve fuel")
 
         self.add_output("fuelburn", val=1.0, units="kg")
+        self.add_output("W_start", val=1.0, units="kg", desc="Mass at start of this phase")
 
         self.declare_partials("*", "*")
         self.set_check_partial_options(wrt="*", method="cs", step=1e-30)
@@ -79,7 +78,8 @@ def compute(self, inputs, outputs):
         CL = inputs["CL"]
         CD = inputs["CD"]
 
-        outputs["fuelburn"] = (W0 + Ws) * (np.exp(R * CT / a / M * CD / CL) - 1)
+        outputs["W_start"] = (W0 + Ws) * (np.exp(R * CT / a / M * CD / CL))
+        outputs["fuelburn"] = outputs["W_start"] - (W0 + Ws)
 
     def compute_partials(self, inputs, partials):
         CT = inputs["CT"]
@@ -96,24 +96,118 @@ def compute_partials(self, inputs, partials):
         CL = inputs["CL"]
         CD = inputs["CD"]
 
-        dfb_dCL = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M * CD / CL**2
-        dfb_dCD = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M / CL
-        dfb_dCT = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R / a / M / CL * CD
-        dfb_dR = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) / a / M / CL * CD * CT
-        dfb_da = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a**2 / M * CD / CL
-        dfb_dM = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M**2 * CD / CL
-
-        dfb_dW = np.exp(R * CT / a / M * CD / CL) - 1
-
-        partials["fuelburn", "CL"] = dfb_dCL
-        partials["fuelburn", "CD"] = dfb_dCD
-        partials["fuelburn", "CT"] = dfb_dCT
-        partials["fuelburn", "speed_of_sound"] = dfb_da
-        partials["fuelburn", "R"] = dfb_dR
-        partials["fuelburn", "Mach_number"] = dfb_dM
-        partials["fuelburn", "W0"] = dfb_dW
+        dW_start_dCL = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M * CD / CL**2
+        dW_start_dCD = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M / CL
+        dW_start_dCT = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R / a / M / CL * CD
+        dW_start_dR = (W0 + Ws) * np.exp(R * CT / a / M * CD / CL) / a / M / CL * CD * CT
+        dW_start_da = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a**2 / M * CD / CL
+        dW_start_dM = -(W0 + Ws) * np.exp(R * CT / a / M * CD / CL) * R * CT / a / M**2 * CD / CL
+
+        dW_start_dW = np.exp(R * CT / a / M * CD / CL)
+
+        partials["W_start", "CL"] = dW_start_dCL
+        partials["W_start", "CD"] = dW_start_dCD
+        partials["W_start", "CT"] = dW_start_dCT
+        partials["W_start", "speed_of_sound"] = dW_start_da
+        partials["W_start", "R"] = dW_start_dR
+        partials["W_start", "Mach_number"] = dW_start_dM
+        partials["W_start", "W0"] = dW_start_dW
+
+        partials["fuelburn", "CL"] = dW_start_dCL
+        partials["fuelburn", "CD"] = dW_start_dCD
+        partials["fuelburn", "CT"] = dW_start_dCT
+        partials["fuelburn", "speed_of_sound"] = dW_start_da
+        partials["fuelburn", "R"] = dW_start_dR
+        partials["fuelburn", "Mach_number"] = dW_start_dM
+        partials["fuelburn", "W0"] = dW_start_dW - 1
 
         for surface in self.options["surfaces"]:
             name = surface["name"]
             inp_name = name + "_structural_mass"
-            partials["fuelburn", inp_name] = dfb_dW
+            partials["W_start", inp_name] = dW_start_dW
+            partials["fuelburn", inp_name] = dW_start_dW - 1
+
+
+class BreguetRangeClimbAndCruise(om.Group):
+    """
+    Breguet range equation for climb and cruise.
+    Computes the fuel burn using the Breguet range equation using
+    the computed CL, CD, weight, and provided specific fuel consumption, speed of sound,
+    Mach number, initial weight, and range.
+
+    Note that we add information from each lifting surface.
+
+    Parameters
+    ----------
+    CL : float
+        Total coefficient of lift (CL) for the lifting surface.
+    CD : float
+        Total coefficient of drag (CD) for the lifting surface.
+    CT : float
+        Specific fuel consumption for the entire aircraft.
+    speed_of_sound : float
+        The speed of sound at cruise.
+    speed_of_sound_climb : float
+        The speed of sound at climb.
+    R : float
+        Cruise range, used to backcalculate the cruise fuel burn.
+    R_climb : float
+        Climb range, used to backcalculate the climb fuel burn.
+    Mach_number : float
+        Cruise Mach number.
+    Mach_number_climb : float
+        Climb Mach number.
+    gamma_climb : float
+        Climb flight path angle
+    The operating empty weight (OEW) - wing structural mass + payload + reserve fuel
+        I.e. this is the landing gross mass, ignoring the descent and landing fuel burn.
+        Supplied in kg despite being a 'weight' due to convention.
+    _structural_mass : float
+        Weight of a single lifting surface's structural spar.
+
+    Returns
+    -------
+    fuelburn : float
+        Computed fuel burn in kg based on the Breguet range equation.
+
+    """
+
+    def initialize(self):
+        self.options.declare("surfaces", types=list)
+
+    def setup(self):
+        # cruise fuel burn
+        self.add_subsystem("cruise", BreguetRange(surfaces=self.options["surfaces"]), promotes_inputs=["*"])
+
+        # climb fuel burn.
+        # First compute equivalent "CD": We replace (D/L) -> cos(gamma) / (L/D) + sin(gamma) = (D cos(gamma) + L sin(gamma) / L
+        self.add_subsystem(
+            "climb_CD_equiv",
+            om.ExecComp(
+                "CD_equiv = (CD * cos(gamma_climb) + CL * sin(gamma_climb))",
+                CD_equiv={'units': None},
+                CD={'units': None},
+                CL={'units': None},
+                gamma_climb={'units': 'rad'},
+            ),
+            promotes_inputs=["gamma_climb", "CD", "CL"],
+        )
+        # By not supplying `surface` and connecting start-of-cruise mass to W0, we can reuse the Breguet component for climb.
+        self.add_subsystem(
+            "climb",
+            BreguetRange(surfaces=[]),
+            promotes_inputs=[
+                "CT",  # this sets same TSFC as cruise
+                ("speed_of_sound", "speed_of_sound_climb"),
+                ("R", "R_climb"),
+                ("Mach_number", "Mach_number_climb"),
+                "CL",
+            ],
+        )
+        self.connect("cruise.W_start", "climb.W0")
+        self.connect("climb_CD_equiv.CD_equiv", "climb.CD")
+
+        # sum fuel burn
+        self.add_subsystem("total_fuelburn", om.AddSubtractComp(output_name="fuelburn", input_names=["cruise_fb", "climb_fb"], units="kg"), promotes_outputs=["*"])
+        self.connect("cruise.fuelburn", "total_fuelburn.cruise_fb")
+        self.connect("climb.fuelburn", "total_fuelburn.climb_fb")
diff --git a/openaerostruct/functionals/total_performance.py b/openaerostruct/functionals/total_performance.py
index 2df5ba0cf..44061c4b6 100644
--- a/openaerostruct/functionals/total_performance.py
+++ b/openaerostruct/functionals/total_performance.py
@@ -1,6 +1,6 @@
 import openmdao.api as om
 
-from openaerostruct.functionals.breguet_range import BreguetRange
+from openaerostruct.functionals.breguet_range import BreguetRange, BreguetRangeClimbAndCruise
 from openaerostruct.functionals.equilibrium import Equilibrium
 from openaerostruct.functionals.center_of_gravity import CenterOfGravity
 from openaerostruct.functionals.moment_coefficient import MomentCoefficient
@@ -18,6 +18,7 @@ def initialize(self):
         self.options.declare("user_specified_Sref", types=bool)
         self.options.declare("internally_connect_fuelburn", types=bool, default=True)
         self.options.declare("strut_braced", default=False, types=bool)
+        self.options.declare("include_climb_Breguet", default=False, types=bool)
 
     def setup(self):
         surfaces = self.options["surfaces"]
@@ -61,12 +62,22 @@ def setup(self):
             promotes_outputs=["CL", "CD", "L", "D"],
         )
 
-        self.add_subsystem(
-            "fuelburn",
-            BreguetRange(surfaces=surfaces_all),
-            promotes_inputs=["*structural_mass", "CL", "CD", "CT", "speed_of_sound", "R", "Mach_number", "W0"],
-            promotes_outputs=["fuelburn"],
-        )
+        if self.options["include_climb_Breguet"]:
+            # climb + cruise fuel burn
+            self.add_subsystem(
+                "fuelburn",
+                BreguetRangeClimbAndCruise(surfaces=surfaces_all),
+                promotes_inputs=["*structural_mass", "CL", "CD", "CT", "speed_of_sound", "speed_of_sound_climb", "R", "R_climb", "Mach_number", "Mach_number_climb", "gamma_climb", "W0"],
+                promotes_outputs=["fuelburn"],
+            )
+        else:
+            # cruise only
+            self.add_subsystem(
+                "fuelburn",
+                BreguetRange(surfaces=surfaces_all),
+                promotes_inputs=["*structural_mass", "CL", "CD", "CT", "speed_of_sound", "R", "Mach_number", "W0"],
+                promotes_outputs=["fuelburn"],
+            )
 
         self.add_subsystem(
             "L_equals_W",
diff --git a/openaerostruct/integration/aerostruct_groups.py b/openaerostruct/integration/aerostruct_groups.py
index 2b4bb1c2d..42e58b466 100644
--- a/openaerostruct/integration/aerostruct_groups.py
+++ b/openaerostruct/integration/aerostruct_groups.py
@@ -368,6 +368,7 @@ def initialize(self):
             "rotational", False, types=bool, desc="Set to True to turn on support for computing angular velocities"
         )
         self.options.declare("strut_braced", default=False, types=bool)
+        self.options.declare("include_climb_Breguet", default=False, types=bool)
 
     def setup(self):
         surfaces = self.options["surfaces"]
@@ -703,6 +704,27 @@ def setup(self):
         # Add functionals to evaluate performance of the system.
         # Note that only the interesting results are promoted here; not all
         # of the parameters.
+        promotes_inputs = [
+            "v",
+            "rho",
+            "empty_cg",
+            "total_weight",
+            "CT",
+            "speed_of_sound",
+            "R",
+            "Mach_number",
+            "W0",
+            "load_factor",
+            "S_ref_total",
+        ]
+        if self.options["include_climb_Breguet"]:
+            # additional inputs for climb fuel burn computation
+            promotes_inputs.extend([
+                "speed_of_sound_climb",
+                "R_climb",
+                "Mach_number_climb",
+                "gamma_climb",
+            ])
         self.add_subsystem(
             "total_perf",
             TotalPerformance(
@@ -710,19 +732,8 @@ def setup(self):
                 strut_braced=self.options["strut_braced"],
                 user_specified_Sref=self.options["user_specified_Sref"],
                 internally_connect_fuelburn=self.options["internally_connect_fuelburn"],
+                include_climb_Breguet=self.options["include_climb_Breguet"],
             ),
-            promotes_inputs=[
-                "v",
-                "rho",
-                "empty_cg",
-                "total_weight",
-                "CT",
-                "speed_of_sound",
-                "R",
-                "Mach_number",
-                "W0",
-                "load_factor",
-                "S_ref_total",
-            ],
+            promotes_inputs=promotes_inputs,
             promotes_outputs=["L_equals_W", "fuelburn", "CL", "CD", "CM", "cg"],
         )

From cb4a4403dc2c7f4f6b9431e481a8f5fbc0f95eba Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 19 Nov 2025 16:17:49 -0500
Subject: [PATCH 28/30] added fuel tank volume fraction

---
 openaerostruct/structures/fuel_vol.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/openaerostruct/structures/fuel_vol.py b/openaerostruct/structures/fuel_vol.py
index e0f8d699f..39e90a5f0 100644
--- a/openaerostruct/structures/fuel_vol.py
+++ b/openaerostruct/structures/fuel_vol.py
@@ -49,4 +49,8 @@ def compute(self, inputs, outputs):
         # Next we multiply the element lengths with the A_int for the internal volumes of the wingobox segments
         vols = element_lengths * inputs["A_int"]
 
+        # fraction of the fuel tank volume to the wingbox volume. This should be <= 1.
+        if "fuel_tank_volume_fraction" in self.options["surface"]:
+            vols *= self.options["surface"]['fuel_tank_volume_fraction']
+
         outputs["fuel_vols"] = vols

From 3ede87aad596dd25c26cce3c58896c85f0d9e5fe Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 19 Nov 2025 16:18:11 -0500
Subject: [PATCH 29/30] style

---
 openaerostruct/structures/fuel_vol.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openaerostruct/structures/fuel_vol.py b/openaerostruct/structures/fuel_vol.py
index 39e90a5f0..3e0b3d229 100644
--- a/openaerostruct/structures/fuel_vol.py
+++ b/openaerostruct/structures/fuel_vol.py
@@ -51,6 +51,6 @@ def compute(self, inputs, outputs):
 
         # fraction of the fuel tank volume to the wingbox volume. This should be <= 1.
         if "fuel_tank_volume_fraction" in self.options["surface"]:
-            vols *= self.options["surface"]['fuel_tank_volume_fraction']
+            vols *= self.options["surface"]["fuel_tank_volume_fraction"]
 
         outputs["fuel_vols"] = vols

From 46e954c0f5189c01b568d209444591a6195d0e8a Mon Sep 17 00:00:00 2001
From: kanekosh <shugok@umich.edu>
Date: Wed, 19 Nov 2025 16:24:00 -0500
Subject: [PATCH 30/30] move fuel volume factor to wingboxfuelvoldelta

---
 openaerostruct/structures/fuel_vol.py               | 4 ----
 openaerostruct/structures/wingbox_fuel_vol_delta.py | 8 +++++++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/openaerostruct/structures/fuel_vol.py b/openaerostruct/structures/fuel_vol.py
index 3e0b3d229..e0f8d699f 100644
--- a/openaerostruct/structures/fuel_vol.py
+++ b/openaerostruct/structures/fuel_vol.py
@@ -49,8 +49,4 @@ def compute(self, inputs, outputs):
         # Next we multiply the element lengths with the A_int for the internal volumes of the wingobox segments
         vols = element_lengths * inputs["A_int"]
 
-        # fraction of the fuel tank volume to the wingbox volume. This should be <= 1.
-        if "fuel_tank_volume_fraction" in self.options["surface"]:
-            vols *= self.options["surface"]["fuel_tank_volume_fraction"]
-
         outputs["fuel_vols"] = vols
diff --git a/openaerostruct/structures/wingbox_fuel_vol_delta.py b/openaerostruct/structures/wingbox_fuel_vol_delta.py
index ff4956b2b..ba1202825 100644
--- a/openaerostruct/structures/wingbox_fuel_vol_delta.py
+++ b/openaerostruct/structures/wingbox_fuel_vol_delta.py
@@ -51,5 +51,11 @@ def compute(self, inputs, outputs):
 
         sum_vols = np.sum(vols)
 
+        # fraction of the fuel tank volume to the wingbox volume. This should be <= 1.
+        if "fuel_tank_volume_fraction" in self.options["surface"]:
+            factor = self.options["surface"]["fuel_tank_volume_fraction"]
+        else:
+            factor = 1.0
+
         # This is used for the fuel-volume constraint. It should be positive for fuel to fit.
-        outputs["fuel_vol_delta"] = sum_vols - (fuel_weight + reserves) / fuel_density
+        outputs["fuel_vol_delta"] = sum_vols * factor - (fuel_weight + reserves) / fuel_density