RCAIDE.Library.Methods.Mass_Properties.Weight_Buildups.Conventional.General_Aviation.FLOPS.compute_wing_weight

compute_wing_weight#

compute_wing_weight(vehicle, wing, WPOD, complexity, settings, num_main_wings)[source]#
Calculate the wing weight using FLOPS methodology for general aviation aircraft. The wing weight consists of:

  • Bending Material Weight

  • Shear Material and Control Surface Weight

  • Miscellaneous Items Weight

Parameters:

  • vehicle (RCAIDE.Vehicle()) –

    Vehicle data structure containing:
    • reference_areafloat

      Wing surface area [m^2]

    • mass_properties.max_takeofffloat

      Maximum takeoff weight [kg]

    • flight_envelope.ultimate_loadfloat

      Ultimate load factor

    • fuselages.widthfloat

      Width of the fuselage [m]

    • networkslist

      List of propulsion networks

  • wing (RCAIDE.Component()) –

    Wing data structure containing:
    • taperfloat

      Wing taper ratio

    • sweeps.quarter_chordfloat

      Quarter chord sweep angle [deg]

    • thickness_to_chordfloat

      Thickness to chord ratio

    • spans.projectedfloat

      Wing span [m]

    • chords.rootfloat

      Root chord [m]

    • chords.tipfloat

      Tip chord [m]

    • twists.rootfloat

      Wing twist at root [deg]

    • twists.tipfloat

      Wing twist at tip [deg]

    • flap_ratiofloat

      Flap area to wing area ratio

  • WPOD (float) – Weight of engine pod including nacelle [kg]

  • complexity (str) – Wing weight method, either “simple” or “complex”

  • settings (Data()) –

    Settings containing:
    • FLOPS.aeroelastic_tailoring_factorfloat

      Aeroelastic tailoring factor [0-1]

    • FLOPS.strut_braced_wing_factorfloat

      Strut braced wing factor [0-1]

    • advanced_compositesbool

      Flag for composite construction

  • num_main_wings (int) – Number of main wings

Returns:

wing_weight – Total wing weight [kg]

Return type:

float

Notes

The function implements two FLOPS methods: a simple and a complex approach. The complex method uses detailed spanwise integration for more accurate results.

Major Assumptions

  • Wing is elliptically loaded

  • Gloved wing area is 0

  • Load between multiple main wings is distributed equally

  • Wing sweep is fixed

  • For complex method: 500 integration stations used

Theory

Simple Method: .. math:

W_w = W_1 + W_2 + W_3
Where:

W_1 (Bending material):

\[W_1 = \frac{DG * CAYE * W_{1NIR} + W_2 + W_3}{1 + W_{1NIR}} - W_2 - W_3\]

W_2 (Shear material): .. math:

W_2 = A_2 * (1 - 0.17F_{comp}) * S_{flap}^{A_3} * DG^{A_4}

W_3 (Miscellaneous): .. math:

W_3 = A_5 * (1 - 0.3F_{comp}) * S_w^{A_6}
Where:

  • W_w is total wing weight [lb]

  • DG is design gross weight [lb]

  • CAYE is engine weight relief factor

  • F_comp is composite utilization factor

  • S_flap is flap area [ft^2]

  • S_w is wing area [ft^2]

  • A_i are empirical constants

Complex Method: Uses numerical integration of spanwise loads with 500 stations. The complex method accounts for:

  • Actual wing geometry through detailed station data

  • Engine weight relief effects

  • Sweep angle variations

  • Thickness distribution

  • Chord distribution

  • Actual load distribution

The process follows:

1. Spanwise Load Distribution: .. math:

P(y) = \sqrt{1 - (\frac{y}{b/2})^2}

2. Local Loads and Moments: .. math:

\Delta P = \frac{\Delta y}{6}[c_0(2P_0 + P_1) + c_1(2P_1 + P_0)]

\Delta M = \frac{\Delta y^2}{12}[c_0(3P_0 + P_1) + c_1(P_1 + P_0)]

3. Cumulative Loads: .. math:

L(y) = \sum_{i=y}^{b/2} \Delta P_i

M(y) = \sum_{i=y}^{b/2} (\Delta M_i + \Delta y L_i) \sec(\Lambda_i)

4. Bending Material Area: .. math:

BMA(y) = \frac{M(y)}{c(y)t(y)} \sec(\Lambda)

5. Engine Effects: .. math:

M_e(y) = \sum_{i=y}^{b/2} \Delta y_i E(y_i) \sec(\Lambda_i)

BMA_e(y) = \frac{M_e(y)}{c(y)t(y)} \sec(\Lambda)

6. Final Wing Weight: .. math:

W_w = W_1 + W_2 + W_3
Where:

  • y is spanwise station location

  • b is wing span

  • c is local chord

  • t is local thickness

  • P is normalized pressure loading

  • Λ is local sweep angle

  • E(y) is engine weight relief

  • W_1 is bending material weight

  • W_2 is shear material weight

  • W_3 is miscellaneous items weight

References

[1] NASA. (1979). The Flight Optimization System Weights Estimation Method.

NASA Technical Report.

generate_wing_stations(fuselage_width, wing)[source]#
Divides half the wing in sections, using the defined sections

and adding a section at the intersection of wing and fuselage

Assumptions:

Source:

The Flight Optimization System Weight Estimation Method

Inputs:

fuselage_width: fuselage width [m] wing: data dictionary with wing properties

-.taper: taper ration wing -.sweeps.quarter_chord: quarter chord sweep angle [deg] -.thickness_to_chord: thickness to chord -.spans.projected: wing span [m] -.chords.root: root chord [m] -.tip.root: tip chord [m] -.twists.root: twist of wing at root [deg] -.twists.tip: twist of wing at tip [deg] -.Segments: trapezoidal segments of the wing

Outputs:

ETA: spanwise location of the sections normalized by half span C: chord lengths at every spanwise location in ETA normalized by half span T: thickness to chord ratio at every span wise location in ETA SWP: quarter chord sweep angle at every span wise location in ETA

Properties Used:

N/A

generate_int_stations(NSD, ETA)[source]#

Divides half of the wing in integration stations

Assumptions:

Source:

The Flight Optimization System Weight Estimation Method

Inputs:

NSD: number of integration stations requested ETA: list of spanwise locations of all sections of the wing

Outputs:

NS: actual number of integration stations Y: spanwise locations of the integrations stations normalized by half span

Properties Used:

N/A

calculate_load(ETA)[source]#

Returns load factor assuming elliptical load distribution

Assumptions:

Source:

The Flight Optimization System Weight Estimation Method

Inputs:

ETA: list of spanwise locations of all sections of the wing

Outputs:

PS: load factor at every location in ETA assuming elliptical load distribution

Properties Used:

N/A

find_sweep(y, lst_y, swp)[source]#

Finds sweep angle for a certain y-location along the wing

Assumptions:

Source:

The Flight Optimization System Weight Estimation Method

Inputs:

y: spanwise location lst_y: list of spanwise stations where sweep is known (eg sections) swp: list of quarter chord sweep angles at the locations listed in lst_y

Outputs:

swps: sweep angle at y

Properties Used:

N/A

get_spanwise_engine(networks, SEMISPAN)[source]#

Returns EETA for the engine locations along the wing

Assumptions:

Source:

The Flight Optimization System Weight Estimation Method

Inputs:
networks: data dictionary with all the engine properties

-.wing_mounted: list of boolean if engine is mounted to wing -.number_of_engines: number of engines -.origin: origin of the engine

SEMISPAN: half span [m]

Outputs:

EETA: span wise locations of the engines mounted to the wing normalized by the half span

Properties Used:

N/A

wing_weight_constants_FLOPS()[source]#

Defines wing weight constants as defined by FLOPS Inputs: ac_type - determines type of instruments, electronics, and operating items based on types:

“short-range”, “medium-range”, “long-range”, “business”, “cargo”, “commuter”, “sst”

Outputs: list of coefficients used in weight estimations

determine_fuselage_chord(fuselage_width, wing)[source]#

Determine chord at wing and fuselage intersection

Assumptions:

Fuselage side of body is between first and second wing segments.

Source:

The Flight Optimization System Weight Estimation Method

Inputs:

fuselage_width: width of fuselage [m] wing: data dictionary with wing properties

-.taper: taper ratio -.sweeps.quarter_chord: quarter chord sweep angle [deg] -.thickness_to_chord: thickness to chord -.spans.projected: wing span [m] -.chords.root: root chord [m]

-.fuselages.fuselage.width: fuselage width [m]

Outputs:

chord: chord length of wing where wing intersects the fuselage wall [ft]

Properties Used:

N/A