Rocket staging - Rocket Propulsion notes

# this line makes figures interactive in Jupyter notebooks
%matplotlib inline
from matplotlib import pyplot as plt

Single stage rocket¶

Figure 1 shows a single-stage rocket. The total mass of the vehicle at liftoff, also called the wet mass, is

m_0 = m_p + m_s + m_{\text{PL}} \;,

(1)

where $m_p$ is the propellant mass, $m_s$ is the structural mass (also called the “inert mass” or “empty mass”), and $m_{\text{PL}}$ is the payload mass. Then, the total mass at burnout, or the dry mass, is

m_b = m_f = m_s + m_{\text{PL}} \;.

(2)

The mass ratio of this rocket, the ratio of wet mass to dry mass, is then

\text{MR} = \frac{m_0}{m_f} > 1 \;,

(3)

which typically ranges 8 to 20. Mass ratio can also be expressed in terms of the component masses:

\text{MR} = \frac{m_p + m_s + m_{\text{PL}}}{m_s + m_{\text{PL}}} = \frac{m_p + m_f}{m_f} = 1 + \frac{m_p}{m_f} \;.

(4)

We can also define a number of other useful mass-related parameters. The payload ratio or payload fraction is the ratio of the payload to the initial vehicle mass (not including the payload itself):

\lambda = \frac{m_{\text{PL}}}{m_0 - m_{\text{PL}}} = \frac{m_{\text{PL}}}{m_p + m_s} \;.

(5)

The structural coefficient relates the structural/inert masses of the vehicle to the combined structural and propellant masses:

\epsilon = \frac{m_s}{m_s + m_p} \;,

(6)

where lower $\epsilon$ indicates better structural efficiency of a vehicle. Components that contribute to $m_s$ include the skin, structure, propellant tank, pumps\slash piping, nozzle, etc.---all the components of the rocket that aren’t propellant or payload. While we generally want $\epsilon$ as small as possible, engineering considerations limit the minimum value in practice: $\epsilon_{\min} \approx 0.06$ .

We can express the mass ratio in terms of the payload ratio and structural coefficient:

\text{MR} = \frac{1 + \lambda}{\epsilon + \lambda} \;.

(7)

and therefore we can also express $\Delta V$ in terms of these:

\Delta V = c \ln \text{MR} = c \ln \left(\frac{1 + \lambda}{\epsilon + \lambda}\right) \;.

(8)

We can also define the propellant mass fraction, which is the fraction of the initial/wet mass that is propellant:

\xi = \frac{m_p}{m_0} = \frac{m_p}{m_P + m_{\text{PL}} + m_s} \;.

(9)

With a little work, we can show that the propellant mass fraction and rocket mass ratio are directly related:

\xi = \frac{MR - 1}{MR} = 1 - \frac{1}{MR} \;.

(10)

Multistage rockets¶

Launch vehicles commonly use multiple stages, which each have their own propellant and inert/structure; the payload of one stage includes all upper stages. When the propellant of one stage is exhausted, that portion of the overall vehicle separates, reducing the overall structural mass. The purpose of staging rockets is essentially to achieve higher velocities, and/or more payload.

There are a few different styles of multiple-stage rockets, as Figure 2 shows for a few examples:

series/tandem: the booster, sustainer(s), and payload are stacked vertically
partial: droppable booster ring; sustainer includes propellant for the booster
parallel: boosters operating in parallel alongside sustainer
piggyback: various configurations, where sustainer stage(s) sit on the back of a booster.

Parallel staging: Ariane 5 — (a)Series/tandem staging: Saturn V

The series/tandem style is the most common, but all see regular use.

Let’s consider a three-stage series/tandem rocket, as shown in Figure 3.

Figure 3:Diagram of a three-stage rocket showing masses for each stage. Stage 1 (booster, on the bottom): $m_{p,1}$ , $m_{s,1}$ , total $m_{0,1}$ . Stage 2 (middle, sustainer): $m_{p,2}$ , $m_{s,2}$ , total $m_{0,2}$ . Stage 3 (top): $m_{\text{PL}}$ , $m_{p,3}$ , $m_{s,3}$ , total $m_{0,3}$ .

Each stage has its own structural/inert and propellant masses; the payload of one stage includes all mass on the stages above it (including the actual vehicle payload at the top). The overall wet mass of the vehicle is the same as for the first stage:

m_0 = m_{0,1} \;,

(11)

and we can iteratively define the initial/wet and final/dry masses of each stage with respect to the next stage:

\begin{align} m_{0,i} &= m_{p,i} + m_{s,i} + m_{0,i+1} \\ m_{f,i} &= m_{s,i} + m_{0,i+1} \;. \end{align}

(12)

We can also define the nondimensional mass parameters for each stage $i$ :

\begin{align} \text{MR}_i &= \frac{m_{0,i}}{m_{f,i}} = \frac{m_{0,i}}{m_{0,i} - m_{p,i}} = \frac{m_{0,i}}{m_{s,i} + m_{0,i+1}} \\ \lambda_i &= \frac{m_{\text{PL},i}}{m_{0,i} - m_{\text{PL},i}} = \frac{m_{0,i+1}}{m_{s,i} + m_{p,i}} = \frac{m_{0,i+1}}{m_{0,i} - m_{0,i+1}} \\ \epsilon_i &= \frac{m_{s,i}}{m_{s,i} + m_{p,i}} = \frac{m_{s,i}}{m_{0,i} - m_{0,i+1}} \;, \end{align}

(13)

and, for each stage, the mass ratio

\text{MR}_i = \frac{1}{\epsilon_i(1 - \lambda_i) + \lambda_i}

(14)

and $\Delta V$ :

\Delta V_i = c_i \ln(\text{MR}_i) \;.

(15)

The overall $\Delta V$ for a vehicle with $N$ stages is then the sum of the contribution from each stage:

\Delta V = \sum_i^N \Delta V_i = \sum_i^N c_i \ln (\text{MR}_i) \;.

(16)

Similar stages¶

A rocket with similar stages shares a common effective exhaust velocity $c$ (meaning, common energetic performance and the same specific impulse $I_{\text{sp}}$ ) and mass ratio MR for each stage:

\text{MR}_i = \text{MR} \\ c_i = c

(17)

and we can express the overall $\Delta V$ as

\Delta V = N c \ln (\text{MR}) \;,

(18)

where $N$ is the number of stages.

It can be shown that similar stages is actually the optimal solution when each stage has the same energetic performance (constant $c$ ).

For a multistage rocket with $N$ similar stages, meaning each stage has the same effective exhaust velocity $c$ and structural ratio $\epsilon$ , the structural/empty mass $m_s$ and propellant mass $m_p$ for the $i$ th stage can be calculated:

\begin{align*} m_{s,i} &= \frac{ \left(1 - \pi_{\text{PL}}^{1/N} \right) \epsilon}{\pi_{\text{PL}}^{(N+1-i)/N}} m_{\text{PL}} \\ m_{p,i} &= \frac{ \left(1 - \pi_{\text{PL}}^{1/N} \right) (1-\epsilon)}{\pi_{\text{PL}}^{(N+1-i)/N}} m_{\text{PL}} \;, \end{align*}

(19)

where $m_{\text{PL}}$ is the payload mass and $\pi_{\text{PL}}$ is the payload fraction ( $m_{\text{PL}} / m_0$ ).

The overall burnout velocity for an $N$ -stage similar-stage rocket is then

v_{bo,N} = c N \log\left( \frac{1}{\pi_{\text{PL}}^{1/N} (1-\epsilon) + \epsilon} \right) \;.

(20)

For an infinite number of stages, the burnout velocity would be

v_{bo, \infty} = c (1 - \epsilon) \log \left( \frac{1}{\pi_{\text{PL}}} \right) \;.

(21)

Example: varying number of stages¶

How does the achievable burnout velocity—which is the maximum $\Delta v$ for a launch vehicle—increase as the number of stages increases? How does this compare with the maximum theoretical velocity?

Determine for a multistage rocket with similar stages, each with $\epsilon = 0.2$ , $c = 3000$ m/s, and an initial mass to payload mass ratio $\frac{m_0}{m_{\text{PL}}} = 30$ .

import numpy as np

struct_coeff = 0.2
eff_exhaust_velocity = 3000
m0_mPL = 30

payload_frac = 1. / m0_mPL
max_stages = 10

stages = list(range(1, max_stages + 1))
delta_v = np.zeros(max_stages)
mass_propellant_payload = np.zeros(max_stages)
for idx, N in enumerate(stages):
    delta_v[idx] = eff_exhaust_velocity * N * np.log(
        1 / (payload_frac**(1./N) * (1 - struct_coeff) + struct_coeff)
        )
    # ratio of stage propellant mass to payload
    for n in range(N):
        mass_propellant_payload[idx] += (
            (1 - payload_frac**(1./N))*(1 - struct_coeff) / payload_frac**((N - n)/N)
            )

delta_v_inf = eff_exhaust_velocity * (1 - struct_coeff) * np.log(1 / payload_frac)

fig, ax = plt.subplots()
ax.bar(stages, delta_v)
ax.set_xlabel('Number of stages')
ax.set_xticks(stages)
ax.set_ylabel('Burnout velocity (m/s)')
ax.axhline(delta_v_inf, ls='--')
ax.set_ylim([0, 10000])
ax.set_title(r'Total $\Delta V$ with number of stages')
plt.show()

Loading...

We can see that shifting from one stage to two and three stages gains a lot in terms of overall $\Delta V$ , but four or more stages has diminishing returns, even compared with the limiting result from an infinite number of stages.

What about propellant mass---how does the overall propellant mass compare for varying stages? To calculate this, we can use above for each stage, sum this up across all stages, and find the ratio of the total propellant mass to overall initial mass:

for idx, N in enumerate(stages):
    # ratio of stage propellant mass to payload
    mass_propellant_payload = 0.0
    for n in range(N):
        mass_propellant_payload += (
            (1 - payload_frac**(1./N))*(1 - struct_coeff) / payload_frac**((N - n)/N)
            )
    print(f'{N} stages: m_p / m_0 = {mass_propellant_payload * payload_frac: .2f}')

1 stages: m_p / m_0 =  0.77
2 stages: m_p / m_0 =  0.77
3 stages: m_p / m_0 =  0.77
4 stages: m_p / m_0 =  0.77
5 stages: m_p / m_0 =  0.77
6 stages: m_p / m_0 =  0.77
7 stages: m_p / m_0 =  0.77
8 stages: m_p / m_0 =  0.77
9 stages: m_p / m_0 =  0.77
10 stages: m_p / m_0 =  0.77

Interesting! With similar stages, the total amount of propellant is constant. However, the size of each stage will necessarily be different---the first stage is largest, and so on.

Let’s examine the amount of propellant in each stage, for both a single-stage and multiple-stage rockets.

mass_propellant_payload = np.zeros((max_stages,max_stages))
for idx, N in enumerate(stages):
    # ratio of stage propellant mass to payload
    for n in range(N):
        mass_propellant_payload[idx, n] = (
            (1 - payload_frac**(1./N))*(1 - struct_coeff) / payload_frac**((N - n)/N)
            )


fig, ax = plt.subplots()
im1 = ax.imshow(mass_propellant_payload * payload_frac,)
cb1 = fig.colorbar(im1, label=r'$m_p / m_0$')

ax.set_ylabel('Number of stages')
ax.set_xlabel('Stage number')
ax.set_title('Fraction of stage propellant mass to overall mass')

labels = [str(idx) for idx in range(1,max_stages+1)]

ax.set_xticks(range(max_stages), labels=labels)
ax.set_yticks(range(max_stages), labels=labels)

for (j,i),label in np.ndenumerate(mass_propellant_payload * payload_frac):
    if label > 0.0:
        if label > 0.5:
            color = 'black'
        else:
            color = 'white'
        ax.text(i,j,f'{label: .2f}',ha='center',va='center',c=color,fontsize='small')

plt.show()

Loading...