(Note: the US spelling is maneuver, but it took me years of muscle memory training to spell manoeuvre correctly, and I won’t be losing it easily.)

Acceleration, Manoeuvres, and Aircraft Loading#

The preceding analysis has been constrained to steady flight - that is, with zero acceleration. For the cases of climb, the climb rate was assumed to be steady.

To understand unconstrained aircraft manoeuvres requires an understanding of accelerated flight.

Manoeuvre will be broken down into horizontal (e.g., flat or banked turns) and vertical manoeuvres (e.g., loops, pull-ups), comprising curvilinear motion. Such manoeuvres are the result of a force perpendicular to the flight path, giving a normal acceleration.

All of the manoevures discussed are the result of a variation in lift, which can be large. Consider that the dynamic pressure rises with the square of the forward speed, so a five-fold speed increase results in twenty-five times the aerodynamic forces.

Before discussing manoeuvres, a means to represent the allowable amount of load on an aircraft will be introduced.

Load Factor#

The load that can be safely taken through an aircraft dictates the load limits on an aircraft - for this the load factor is introduced as a non-dimensional measure of the load variation.

(12)#\[n=\frac{L}{W}\]

So - what is the load factor for steady level flight?

In steady level flight, the equilibrium steady flight condition is \(L=W\) so \(n=1\)

There are two structural limits defined for aircraft:

  • Limit Loads, \(n_{l}\) are the loads at which plastic deformation will occur. At flight with \(1<n<n_1\), elastic structural deformation will occur on parts of the aircraft, and the parts will return to the design or equilibrium position once the loads are removed

    If flight occurs at \(n>n_l\), the aircraft will require inspection and likely replacement of parts.

  • Ultimate Loads, \(n_{u}\) are the loads at which failure will occur. At flight with \(n>n_u\), parts of the aircraft will break

The numerical value of the load factor is an exercise in structural analysis, whereby the loads and their paths are applied to a model of the aircraft, and a determination of \(n_l\) and \(n_u\) can be made.

In general, \(n_l\) and \(n_u\) will be defined with a safety factor of 50% - such that plastic structural deformation may not actually occur until \(n_l*1.5\). This should not be considered a margin to ‘play with’, however!

Values of the load factor#

FAR 23 (Federal Aviation Requirement) dictates the minimum load factor required for three categories of aircraft:

  • Commuter Aircraft

  • Utility Aircraft

  • Aerobatic Aircraft

The minimum load factors are defined as (since this is from FAR 23, \(W\) is defined in \(lbf\))

Aircraft Category

Minimum positive load factor, \(n+\)

Minimum negative load factor, \(n-\)

Normal/Commuter

smaller of \(2.1+\frac{24000}{W+1000}\) or \(3.8\)

\(0.4n+\)

Utility

\(4.4\)

\(0.4n+\)

Aerobatic

\(6.0\)

\(0.5n+\)

Often pilots will talk about load factor in terms of “g”s - for straight and level flight, 1\(g\) feels like regular earth gravity, whilst an \(n=2\) or \(2g\) manoeuvre makes the occupants feel twice as heavy.

Since the load factor represents the amount of lift being produced, it is an easy and instructive means to define the structural limits of an aircraft - \(e.g.,\) the loads for which the wings will break off.

V-n diagram#

Bear in mind…

In what’s becoming a common phrase in this document - the following is a simplification of the theory, designed to give you a good insight into the physics of the problem. Construction of a full \(V-n\) diagram is complicated and more of an exercise in understanding FAA certification than it is the flight physics.

What follows is a suitable explanation for an undergraduate aerospace engineer.

The values of the limit loads, and ultimate loads are presented on a graph vs. airspeed. For the following, the loads will be presented against equivalent airspeed because that enables a single graph to be plotted, but for real aircraft this is usually presented against indicated airspeed, with several lines representing different altitudes.

There are many different means of showing how to construct a \(V-n\) diagram in textbook and online, but most seem geared up to helping pilots understand them rather than aerospace engineers. For example - the following show good examples of how to formulate a \(V-n\) diagram, website one, website two.

For the following example, a representative jet trainer aircraft will be used, with structural limit loads of \(-3.0<n_l<7.0\) and ultimate loads of \(-5.0<n_u<11.0\).

For a range of flight speeds up to \(M=1.0\), the loads above can be plotted against \(EAS\) taking into account the \(n\) values above only.

import numpy as np
import plotly.graph_objects as go

# Limit loads
n_l = [-3.0, 7.0]

# Ultimate loads
n_u = [-5.0, 11.0]

# Make a figure
fig = go.Figure()

# Make a vector of equivalent airspeed (m/s)
VE = np.linspace(0, 340, 1000)

# Plot the Structural damage area
x_structural_damage = [VE.min(), VE.max()]
y_structural_damage = [n_l[1], n_l[1]]
y_structural_failure = [n_u[1], n_u[1]]

## Positive strucutral damage
# Plot a line of the structural damage
fig.add_trace(go.Scatter(x=VE, y=n_l[1] * np.ones(VE.shape),
    fill=None,
    mode='lines',
    line_color='indigo', name="+nl",
    showlegend=False))

# Then a line of the structural failure that is filled to the structural damage
fig.add_trace(go.Scatter(
    x=x_structural_damage,
    y=y_structural_failure,
    fill='tonexty', # fill area between structural failure and structural Damage
    mode='none', fillcolor='rgba(255, 0, 0, 0.25)', name="Structural Damage", showlegend=False))

# Annotate the structural failure area
fig.add_trace(go.Scatter(
    x=[np.mean(x_structural_damage)],
    y=[0.5 * (n_l[1] + n_u[1])],
    mode='text',
    text="Structural Damage", showlegend=False))

# Add the ultimate load factor
fig.add_trace(go.Scatter(x=VE, y=n_u[1] * np.ones(VE.shape),
    mode='lines',
    line_color='red', name="+nu",
    showlegend=False))

# Then a line of the structural failure that is filled to the structural damage
fig.add_trace(go.Scatter(
    x=VE, y=3*n_u[1] * np.ones(VE.shape),
    fill='tonexty', # fill area between structural failure and structural Damage
    mode='none', fillcolor='rgba(255, 0, 0, 0.55)', name="Structural Damage", showlegend=False, hoverinfo="none"))

# Annotate the structural failure area
fig.add_trace(go.Scatter(
    x=[np.mean(x_structural_damage)],
    y=[n_u[1] + 0.05 * (n_l[1] + n_u[1])],
    mode='text',
    text="Structural Failure", showlegend=False, hoverinfo="none"))




### Negative side



## Negative structural damage
x_structural_damage = [VE.min(), VE.max()]
y_structural_damage = [n_l[0], n_l[0]]
y_structural_failure = [n_u[0], n_u[0]]
# Plot a line of the structural damage
fig.add_trace(go.Scatter(x=VE, y=n_l[0] * np.ones(VE.shape),
    fill=None,
    mode='lines',
    line_color='indigo',
    name="-nl",
    showlegend=False))

# Then a line of the structural failure that is filled to the structural damage
fig.add_trace(go.Scatter(
    x=x_structural_damage,
    y=y_structural_failure,
    fill='tonexty', # fill area between trace0 and trace1
    mode='none', fillcolor='rgba(255, 0, 0, 0.25)', name="Structural Damage", showlegend=False))

# Annotate the structural damage area
fig.add_trace(go.Scatter(
    x=[np.mean(x_structural_damage)],
    y=[0.5 * (n_l[0] + n_u[0])],
    mode='text',
    text="Structural Damage", showlegend=False))

# Add the ultimate load factor
fig.add_trace(go.Scatter(x=VE, y=n_u[0] * np.ones(VE.shape),
    fill=None,
    mode='lines',
    line_color='red', name="-nu",
    showlegend=False))

# Then a line of the structural failure that is filled to the structural damage
fig.add_trace(go.Scatter(
    x=VE, y=3*n_u[0] * np.ones(VE.shape),
    fill='tonexty', # fill area between structural failure and structural Damage
    mode='none', fillcolor='rgba(255, 0, 0, 0.55)', name="Structural Damage", showlegend=False, hoverinfo="none"))


# Annotate the structural failure area
fig.add_trace(go.Scatter(
    x=[np.mean(x_structural_damage)],
    y=[n_u[0] + 0.05 * (n_l[0] + n_u[0])],
    mode='text',
    text="Structural Failure", showlegend=False, hoverinfo="none"))

# Change the limits
fig.update_yaxes(range= [1.2 * n_u[0], 1.2 * n_u[1]])

fig.update_layout(
    title="Representative Structural Damage and Failure Load Factors",
    xaxis_title="$V_E/\\text{m/s}$",
    yaxis_title="$n$",
)

# Dick around with the hover behaviour
fig.update_traces(hovertemplate=None)
fig.update_layout(hovermode="x unified")

fig.update_yaxes(zeroline=True, zerolinewidth=2, zerolinecolor='black')
fig.show()