### Categories

### Art and Web Design

Contact me for information about rates and availability.

### Latest Articles

### Rocket Propulsion Using Python

In this tutorial we will focus on the fundamental elements of various rocket propulsion systems and learn how we can use the Python programming language to compute these elements. We will focus on the Ariane 5, Atlas V and Saturn V rocket engines. In our analysis we will consider both the liquid propellant rocket engines and solid propellant rocket boosters used in each of the rockets listed above.

We will begin with a brief discussion on the fundamental elements of rocket propulsion and then we will attempt to calculate these elements using Python. For starters, rocket propulsion is a class of jet propulsion that produces thrust by ejecting liquid or solid matter stored within the rocket, which is called the propellant.

This tutorial focuses on chemical rocket engines. These types of engines derive energy from a high-pressure combustion reaction of propellant chemicals, typically a fuel and an oxidizer, which is heated to very high temperatures (4500 to 7400°F) and subsequently expanded in a nozzle and accelerated to high velocities (1800 to 4300 m/sec). Liquid rocket engines can be started and shut off at will. With solid propellant rocket motors, common on booster rockets, the propellant to be burned is contained within the combustion chamber and once ignited, will burn smoothly at a predetermined rate. Once ignited, solid propellant rockets cannot be shut off.

### Definitions and Equations

**Rocket Propulsion Elements:**

Effective Exhaust Velocity

Mass Flow Rate

Thrust

Thrust-to-Weight Ratio

Mass Ratio

Propellant Mass Fraction

Specific impulse (I_{s}) represents the total impulse per unit weight of propellant. The specific impulse of a rocket propellant provides a rough measurement of how fast the propellant is ejected out of the back of the rocket. A higher number indicates better performance.

I_{s} = c / g_{0} = F / ṁ * g_{0}

Effective exhause velocity (c) is a measure of the average equivalent velocity at which propellant is ejected from the rocket nozzle. It is measured in meters per second, and like specific impulse, the effective exhaust velocity can be used as a measure of rocket performance.

c = I_{s} * g_{0} = F / ṁ

Mass flow rate (ṁ) describes the rate at which a mass of propellant passes through the rockets exhaust nozzel, per unit of time (kg/sec).

ṁ = (m_{0} - m_{f}) / t_{b} = F / I_{s} * g_{0}

Thrust (F) is the force produced by a rocket propulsion system acting upon a rocket. Thrust occurs when mass, in the form of a chemical propellant, is ejected from the rockets thrust chamber through its exhaust nozzel.

F = I_{s} * ṁ * g_{0} = c * ṁ

Thrust-to-weight ratio (F / w_{0}) expresses the acceleration that the engine is capable of giving to its own loaded propulsion system mass. For a constant thrust, the maximum value of the thrust-to-weight ratio, or maximum acceleration, occurs right before termination or burnout because the vehicle mass has been diminished by the mass of useful propellant, which has been expelled.

Mass ratio (M_{R}) is another measure of the efficiency of a rocket propulsion system. It is defined to be the final mass (m_{f}) of the rocket divided by its initial mass (m_{0}). This ratio describes how much more massive the rocket is with the added propellant than it is without propellant, that is the rocket's *wet mass* versus its *dry mass*. More efficient rocket propulsion systems require less propellant to achieve a given goal, therefore a lower mass ratio indicates higher performance.

M_{R} = m_{f} / m_{0}

Propellant mass fraction (ζ) indicates the fraction of propellant mass (m_{p}) in an initial mass (m_{0}). It can be applied to the entire rocket, or each stage of the rocket's propulsion system.

ζ = m_{p} / m_{0} = (m_{0} - m_{f}) / m_{0} = m_{p} / (m_{p} + m_{f})

### Propulsion System Data for Three Major Launch Vehicles

In order to test the above equations, we will focus on three major space launch vehicles: the Ariane 5, Atlas V and Saturn V. More specifically, we will take a closer look at their propulsion systems and compare the performance of each stage to determine which vehicle has the best propulsion systems. Before we compare each propulsion system, we need to collect some baseline data on each vehicle. For this purpose, I used Wikipedia to collected the following data.

Vehicle | Propulsion System |
Stage | Thrust | Specific Impulse |
Burn Time |
Initial Mass |
Final Mass |
---|---|---|---|---|---|---|---|

Ariane 5 | EAP P241 | Booster | 7,080,000 N | 274.5 s | 140 s | 301,000 kg | 36,000 kg |

EPC H173 | First | 960,000 N | 310 s | 540 s | 19,440 kg | 4,540 kg | |

ESC-A | Second | 67,000 N | 446 s | 945 s | 184,700 kg | 14,700 kg | |

Atlas V | AJ-60A | Booster | 1,688,400 N | 279 s | 94 s | 46,697 kg | 4,067 kg |

Atlas CCB | First | 3,827,000 N | 311.3 s | 253 s | 305,143 kg | 21,054 kg | |

Centaur | Second | 99,200 N | 450.5 s | 842 s | 23,146 kg | 2,316 kg | |

Saturn V | S-IC | First | 35,100,000 N | 263 s | 168 | 2,290,000 kg | 130,000 kg |

S-II | Second | 5,141,000 N | 421 s | 360 s | 496,200 kg | 40,100 kg | |

S-IVB | Third | 1,000,000 N | 421 s | 165 s | 123,000 kg | 13,500 kg |

Using the above data we can begin our calculations.
Note that the calculations for the boosters and first stage propulsion systems will assume gravitational acceleration at sea level. Second and third stage propulsion systems can be calculated using the gravitational acceleration at altitudes higher than sea level. For more information on the effects of altitude on gravity, see my article Effects of Gravity at Altitude. For gravitational acceleration at sea level, the following equation may be used.

gravity_earth = G * M_{e} / R_{e}^{2}

gravity_earth = 6.67408^{-11} * 5.98^{24} / 6378.8^{2}

gravity_earth = 9.81 m/sec^{2}

Since we already have the thrust and specific impulse variables for each propulsion system, we can use these numbers to verify our calculations. Let's begin by calculating the mass flow rate (ṁ) in Python, as this variable can be used in many other equations. Since we will be comparing multiple rocket propulsion systems, it is more efficient to create a list of lists for each rocket propulsion element that we will be investigating.

```
```
>>> G = 6.67408 * 10**-11 # Universal gravitational constant
>>> mass_earth = 5.98 * 10**24 # mass of Earth in kilograms
>>> radius_earth = 6378.8 * 10**3 # distance from center of Earth to its surface, converted to meters
>>> gravity_earth = G * mass_earth / radius_earth**2 # calculates gravitational acceleration at sea level
>>> ariane_5 = [
... ["Eap P241", "Booster", 7080000, 274.5, 140, 301000, 36000],
... ["EPC H173", "First", 960000, 310, 540, 184700, 14700],
... ["ESC-A", "Second", 67000, 446, 945, 19440, 4540]
...]
>>> atlas_v = [
... ["AJ-60A", "Booster", 1688400, 279, 94, 46697, 4067],
... ["Atlas CCB", "First", 3827000, 311.3, 253, 305143, 21054],
... ["Centaur", "Second", 99200, 450.5, 842, 23146, 2316]
...]
>>> saturn_v = [
... ["S-IC", "First", 35100000, 263, 168, 2290000, 130000],
... ["S-II", "Second", 5141000, 421, 360, 496200, 40100],
... ["S-IVB", "Third", 1000000, 421, 165, 123000, 13500]
... ]

Now we can calculate mass flow rate using the information defined in our lists. For example, to calculate the mass flow rate for the Ariane 5 booster rocket we can retrieve individual data elements for thrust and specific impulse from our list by using index values (ariane_5[0][2]) and (ariane_5[0][3]), respectively.

```
```
>>> mass_flow_rate = ariane_5[0][2] / (ariane_5[0][3] * gravity_earth)
>>> mass_flow_rate
2629.1895745948987

With the mass flow rate and thrust variables we can now calculate the effective exhaust velocity. We do this by dividing thrust by mass flow rate. Note, we can also calculate the effective exhaust veolity by multiplying the specific impulse by the gravitational acceleration.

```
```
>>> effective_exhaust_velocity = ariane_5[0][2] / mass_flow_rate
>>> effective_exhaust_velocity
2692.8450000000003
>>> effective_exhaust_velocity = ariane_5[0][3] * gravity_earth
>>> effective_exhaust_velocity
2692.8450000000003

Now we can use both the mass flow rate and effective exhaust velocity to calculate thrust, which we will verify using the information obtained from the internet.

```
```
>>> thrust = effective_exhaust_velocity * mass_flow_rate
>>> thrust
7079897

We can also calculate the specific impulse and compare it to what we collected from Wikipedia. We have a couple of equations that will give us specific impulse. The first equation uses the effective exhaust velocity that we just calculated, the other uses the mass flow rate.

```
```
>>> specific_impulse = effective_exhaust_velocity / gravity_earth
>>> specific_impulse
274.5158002038736
>>> specific_impulse = ariane_5[0][2] / mass_flow_rate * gravity_earth
>>> specific_impulse
274.51979392403945

Using the initial mass and final mass of the rocket propulsion system we can calculate the mass ratio, which indicates the efficiency of the rocket engine.

```
```
>>> mass_ratio = ariane_5[0][6] / ariane_5[0][5]
>>> mass_ratio
0.11960132890365449

Lastly, we can calculate the propellant mass fraction using either initial and final mass of the propulsion system. We could also use the mass ratio we just calculated to achieve the same results.

```
```
>>> propellant_mass_fraction = (ariane_5[0][5]-ariane_5[0][6])/ariane_5[0][5]
>>> propellant_mass_fraction
0.8803986710963455

### The Complete Code

The Complete code for this project is listed below. You can also download this code from my GitHub page.

```
```
########################################################
# #
# Propulsion Systems #
# Written by Johnathan Nicolosi #
# #
########################################################
G = 6.67408 * 10**-11 # Universal gravitational constant
mass_earth = 5.98 * 10**24 # mass of Earth in kilograms
radius_earth = 6378.8 * 10**3 # distance from center of Earth to its surface, converted to meters
gravity_earth = G * mass_earth / radius_earth**2 # calculates gravitational acceleration at sea level
rocket_propulsion_elements = ["Propulsion System", "Stage", "Thrust", "Specific Impulse", "Burn Time", "Initial Mass",
"Final Mass"]
########################################################
# Ariane 5 #
########################################################
def ariane_5():
ariane_5_list = [
["Eap P241", "Booster", 7080000, 274.5, 140, 301000, 36000],
["EPC H173", "First", 960000, 310, 540, 184700, 14700],
["ESC-A", "Second", 67000, 446, 945, 19440, 4540]
]
print("###################################################")
print("# Ariane 5 #")
print("###################################################")
print("Ariane 5 -", ariane_5_list[0][0])
mass_flow_rate = ariane_5_list[0][2] / (ariane_5_list[0][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = ariane_5_list[0][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = ariane_5_list[0][6] / ariane_5_list[0][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (ariane_5_list[0][5]-ariane_5_list[0][6])/ariane_5_list[0][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Ariane 5 -", ariane_5_list[1][0])
mass_flow_rate = ariane_5_list[1][2] / (ariane_5_list[1][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = ariane_5_list[1][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = ariane_5_list[1][6] / ariane_5_list[1][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (ariane_5_list[1][5]-ariane_5_list[1][6])/ariane_5_list[1][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Ariane 5 -", ariane_5_list[2][0])
mass_flow_rate = ariane_5_list[2][2] / (ariane_5_list[2][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = ariane_5_list[2][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = ariane_5_list[2][6] / ariane_5_list[2][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (ariane_5_list[2][5]-ariane_5_list[2][6])/ariane_5_list[2][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("")
ariane_5()
########################################################
# Atlas V #
########################################################
def atlas_v():
atlas_v_list = [
["AJ-60A", "Booster", 1688400, 279, 94, 46697, 4067],
["Atlas CCB", "First", 3827000, 311.3, 253, 305143, 21054],
["Centaur", "Second", 99200, 450.5, 842, 23146, 2316]
]
print("###################################################")
print("# Atlas V #")
print("###################################################")
print("Atlas V -", atlas_v_list[0][0])
mass_flow_rate = atlas_v_list[0][2] / (atlas_v_list[0][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = atlas_v_list[0][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = atlas_v_list[0][6] / atlas_v_list[0][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (atlas_v_list[0][5]-atlas_v_list[0][6])/atlas_v_list[0][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Atlas V -", atlas_v_list[1][0])
mass_flow_rate = atlas_v_list[1][2] / (atlas_v_list[1][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = atlas_v_list[1][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = atlas_v_list[1][6] / atlas_v_list[1][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (atlas_v_list[1][5]-atlas_v_list[1][6])/atlas_v_list[1][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Atlas V -", atlas_v_list[2][0])
mass_flow_rate = atlas_v_list[2][2] / (atlas_v_list[2][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = atlas_v_list[2][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = atlas_v_list[2][6] / atlas_v_list[2][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (atlas_v_list[2][5]-atlas_v_list[2][6])/atlas_v_list[2][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("")
atlas_v()
########################################################
# Saturn V #
########################################################
def saturn_v():
saturn_v_list = [
["S-IC", "First", 35100000, 263, 168, 2290000, 130000],
["S-II", "Second", 5141000, 421, 360, 496200, 40100],
["S-IVB", "Third", 1000000, 421, 165, 123000, 13500]
]
print("###################################################")
print("# Saturn V #")
print("###################################################")
print("Saturn V -", saturn_v_list[0][0])
mass_flow_rate = saturn_v_list[0][2] / (saturn_v_list[0][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = saturn_v_list[0][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = saturn_v_list[0][6] / saturn_v_list[0][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (saturn_v_list[0][5]-saturn_v_list[0][6])/saturn_v_list[0][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Saturn V -", saturn_v_list[1][0])
mass_flow_rate = saturn_v_list[1][2] / (saturn_v_list[1][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = saturn_v_list[1][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = saturn_v_list[1][6] / saturn_v_list[1][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (saturn_v_list[1][5]-saturn_v_list[1][6])/saturn_v_list[1][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
print("---------------------------------------------------")
print("Saturn V -", saturn_v_list[2][0])
mass_flow_rate = saturn_v_list[2][2] / (saturn_v_list[2][3] * gravity_earth)
print("Mass Flow Rate:", mass_flow_rate)
effective_exhaust_velocity = saturn_v_list[2][2] / mass_flow_rate
print("Effective Exhaust Velocity:", effective_exhaust_velocity)
thrust = effective_exhaust_velocity * mass_flow_rate
print("Thrust:", thrust)
specific_impulse = effective_exhaust_velocity / gravity_earth
print("Specific Impulse:", specific_impulse)
mass_ratio = saturn_v_list[2][6] / saturn_v_list[2][5]
print("Mass Ratio:", mass_ratio)
propellant_mass_fraction = (saturn_v_list[2][5]-saturn_v_list[2][6])/saturn_v_list[2][5]
print("Propellant Mass Fraction:", propellant_mass_fraction)
saturn_v()