Calculating Escape Velocity in Python

Imagine throwing a ball upward. It always falls back down, right? But what if you threw it so hard that it never came back? That's escape velocity - the minimum speed needed to break free from a planet's gravity. Today we'll write a program that calculates this speed for any celestial body using NumPy - Python's powerful library for scientific computing.

Why NumPy Instead of Regular Python?

While Python's built-in math functions work fine for simple calculations, NumPy offers several advantages for scientific computing:

• More efficient for large-scale calculations
• Better numerical stability and precision control
• Vectorized operations - calculate for multiple planets at once
• Industry standard for scientific Python

Let's install NumPy first (if you haven't already):

pip install numpy

Understanding the Problem

Before we start coding, let's think about what we actually need to do:

1. We know the physics formula: v = √(2GM/r)
2. We need input data: planet's mass and radius
3. We must perform mathematical calculations
4. We'll display the result in a readable format

Sounds simple? That's because it is. But first, we need to understand one important concept used in astronomical calculations.

Scientific Notation - A Way to Handle Huge Numbers

Earth's mass is about 5,972,000,000,000,000,000,000,000 kilograms. Inconvenient to write, right? That's why in science we use scientific notation:

5.972 × 10²⁴ kg

In Python we write this as 5.972e24, where:

• 5.972 is the significand or mantissa (main number)
• e means "times 10 to the power of"
• 24 is the exponent (how many places we need to move the decimal point)

Some examples with NumPy:

import numpy as np

# Scientific notation in NumPy
earth_mass = np.float64(5.972e24)      # 5.972 × 10²⁴
earth_radius = np.float64(6.371e6)     # 6.371 × 10⁶ (6,371,000 meters)
gravity_constant = np.float64(6.674e-11)  # 6.674 × 10⁻¹¹ (very small number)

# NumPy handles these numbers efficiently
print(f"Earth's mass: {earth_mass}")  # Will display: 5.972e+24
print(f"That is: {earth_mass:,.0f}")  # Will display with all zeros

Note: The displayed number might not show exact zeros at the end due to floating-point precision, but NumPy's float64 provides excellent accuracy for our calculations.

Breaking Down the Problem into Steps

Now that we understand notation, let's break down our solution step by step:

Step 1: Define Constants and Data

First, let's specify what we know:

import numpy as np

# Gravitational constant - always the same in the universe
G = np.float64(6.67430e-11)  # m³ kg⁻¹ s⁻²

# Data for Earth (as an example)
earth_mass = np.float64(5.972e24)  # kilograms
earth_radius = np.float64(6.371e6)  # meters (6371 km)

Step 2: Apply the Formula

Now let's substitute into the formula v = √(2GM/r):

# Calculation step by step
numerator = 2 * G * earth_mass
denominator = earth_radius
division_result = numerator / denominator
escape_velocity = np.sqrt(division_result)

print(f"Escape velocity: {escape_velocity:.0f} m/s")

Step 3: Simplify the Code

Once we understand each step, we can write it more concisely:

import numpy as np

G = np.float64(6.67430e-11)
earth_mass = np.float64(5.972e24)
earth_radius = np.float64(6.371e6)

escape_velocity = np.sqrt(2 * G * earth_mass / earth_radius)
print(f"Escape velocity from Earth: {escape_velocity/1000:.1f} km/s")

Version 1: Reusable Function

Instead of copying code for each planet, let's create a function:

import numpy as np

def calculate_escape_velocity(mass, radius):
    """
    Calculates escape velocity for any celestial body.
    
    Parameters:
        mass: mass in kilograms
        radius: radius in meters
    
    Returns:
        escape velocity in m/s
    """
    G = np.float64(6.67430e-11)
    return np.sqrt(2 * G * mass / radius)

# Test for different planets
print("ESCAPE VELOCITIES IN THE SOLAR SYSTEM")
print("-" * 40)

# Earth
v = calculate_escape_velocity(5.972e24, 6.371e6)
print(f"Earth: {v/1000:.1f} km/s")

# Mars
v = calculate_escape_velocity(6.417e23, 3.3895e6)
print(f"Mars: {v/1000:.1f} km/s")

# Moon
v = calculate_escape_velocity(7.342e22, 1.7374e6)
print(f"Moon: {v/1000:.1f} km/s")

Version 2: Program with Planet Database

Now let's create a more useful program with a ready-made database. NumPy really shines here with vectorized operations:

import numpy as np

# Dictionary with planet data
planets = {
    "Mercury": {"mass": 3.301e23, "radius": 2.4397e6},
    "Venus": {"mass": 4.867e24, "radius": 6.0518e6},
    "Earth": {"mass": 5.972e24, "radius": 6.371e6},
    "Mars": {"mass": 6.417e23, "radius": 3.3895e6},
    "Jupiter": {"mass": 1.898e27, "radius": 6.9911e7},
    "Saturn": {"mass": 5.683e26, "radius": 5.8232e7},
    "Uranus": {"mass": 8.681e25, "radius": 2.5362e7},
    "Neptune": {"mass": 1.024e26, "radius": 2.4622e7},
    "Moon": {"mass": 7.342e22, "radius": 1.7374e6}
}

def calculate_escape_velocity(mass, radius):
    G = np.float64(6.67430e-11)
    return np.sqrt(2 * G * mass / radius)

def show_planet_data(name, data):
    """Displays planet data and its escape velocity."""
    v_escape = calculate_escape_velocity(data["mass"], data["radius"])
    
    print(f"\n{name}:")
    print(f"  Mass: {data['mass']:.2e} kg")
    print(f"  Radius: {data['radius']/1000:.0f} km")
    print(f"  Escape velocity: {v_escape:.0f} m/s ({v_escape/1000:.1f} km/s)")

# Display data for all planets
print("="*50)
print("ESCAPE VELOCITIES IN THE SOLAR SYSTEM")
print("="*50)

for planet_name, planet_data in planets.items():
    show_planet_data(planet_name, planet_data)

# Bonus: Calculate all at once using NumPy arrays!
print("\n" + "="*50)
print("VECTORIZED CALCULATION WITH NUMPY")
print("="*50)

names = list(planets.keys())
masses = np.array([planets[p]["mass"] for p in names])
radii = np.array([planets[p]["radius"] for p in names])

# Calculate all escape velocities at once
G = np.float64(6.67430e-11)
all_velocities = np.sqrt(2 * G * masses / radii)

for i, name in enumerate(names):
    print(f"{name}: {all_velocities[i]/1000:.1f} km/s")

Version 3: Interactive Calculator

Now the most interesting part - a program that lets users choose planets or enter their own data:

import numpy as np

# Planet database
planets_db = {
    "1": {"name": "Mercury", "mass": 3.301e23, "radius": 2.4397e6},
    "2": {"name": "Venus", "mass": 4.867e24, "radius": 6.0518e6},
    "3": {"name": "Earth", "mass": 5.972e24, "radius": 6.371e6},
    "4": {"name": "Mars", "mass": 6.417e23, "radius": 3.3895e6},
    "5": {"name": "Jupiter", "mass": 1.898e27, "radius": 6.9911e7},
    "6": {"name": "Saturn", "mass": 5.683e26, "radius": 5.8232e7},
    "7": {"name": "Uranus", "mass": 8.681e25, "radius": 2.5362e7},
    "8": {"name": "Neptune", "mass": 1.024e26, "radius": 2.4622e7},
    "9": {"name": "Moon", "mass": 7.342e22, "radius": 1.7374e6}
}

def calculate_escape_velocity(mass, radius):
    """Calculates escape velocity using NumPy."""
    G = np.float64(6.67430e-11)
    mass = np.float64(mass)
    radius = np.float64(radius)
    return np.sqrt(2 * G * mass / radius)

def display_menu():
    """Displays selection menu."""
    print("\n" + "="*50)
    print("ESCAPE VELOCITY CALCULATOR (NumPy Edition)")
    print("="*50)
    print("\nChoose a planet:")
    
    for key, planet in planets_db.items():
        print(f"  {key}. {planet['name']}")
    
    print("\n  10. Enter custom parameters")
    print("  0. Exit")
    print("-"*50)

def get_custom_parameters():
    """Gets parameters from user."""
    print("\nENTER CELESTIAL BODY DATA")
    
    name = input("Name: ")
    
    while True:
        try:
            mass_str = input("Mass in kg (e.g. 5.972e24): ")
            mass = float(mass_str)
            if mass <= 0:
                print("Mass must be positive!")
                continue
            break
        except ValueError:
            print("Invalid value! Try again.")
    
    while True:
        try:
            radius_str = input("Radius in km: ")
            radius = float(radius_str) * 1000  # convert to meters
            if radius <= 0:
                print("Radius must be positive!")
                continue
            break
        except ValueError:
            print("Invalid value! Try again.")
    
    return name, mass, radius

def display_results(name, mass, radius):
    """Displays calculation results."""
    v_escape = calculate_escape_velocity(mass, radius)
    
    print(f"\n{'='*50}")
    print(f"RESULTS FOR: {name}")
    print(f"{'='*50}")
    print(f"Mass: {mass:.2e} kg")
    print(f"Radius: {radius/1000:,.0f} km")
    print(f"\nEscape velocity:")
    
    # Better handling of very small values
    if v_escape < 0.01:
        print(f"  → {v_escape:.2e} m/s")
    else:
        print(f"  → {v_escape:,.0f} m/s")
        print(f"  → {v_escape/1000:.2f} km/s")
    
    # Compare with Earth
    earth_v = calculate_escape_velocity(5.972e24, 6.371e6)
    if name.lower() != "earth":
        ratio = v_escape / earth_v
        print(f"\nCompared to Earth: {ratio:.2f}x")

def main():
    """Main program loop."""
    print("Welcome to the escape velocity calculator!")
    print("Powered by NumPy for accurate scientific calculations")
    
    while True:
        display_menu()
        choice = input("\nYour choice: ")
        
        if choice == "0":
            print("\nGoodbye! ?")
            break
        elif choice in planets_db:
            planet = planets_db[choice]
            display_results(planet["name"], planet["mass"], planet["radius"])
        elif choice == "10":
            name, mass, radius = get_custom_parameters()
            display_results(name, mass, radius)
        else:
            print("\nInvalid choice!")
        
        input("\nPress Enter to continue...")

# Run the program
if __name__ == "__main__":
    main()

Example Use for an Unknown Planet

Let's say a new exoplanet was discovered. You can use the "custom parameters" option and enter:

• Name: Kepler-452b
• Mass: 3.0e25 kg (5 times Earth's mass)
• Radius: 9556 km (1.5 times Earth's radius)

The program will calculate the escape velocity and compare it to Earth. It's a great way to explore hypothetical scenarios!

NumPy's Power: Batch Calculations

One of NumPy's superpowers is calculating for multiple objects at once:

import numpy as np

# Calculate escape velocities for multiple bodies at once
names = np.array(['Small Asteroid', 'Large Asteroid', 'Moon-sized'])
masses = np.array([1e15, 1e18, 1e22])  # kg
radii = np.array([10000, 100000, 1000000])  # meters

G = np.float64(6.67430e-11)
velocities = np.sqrt(2 * G * masses / radii)

print("Batch calculation results:")
for i in range(len(names)):
    print(f"{names[i]}: {velocities[i]:.2f} m/s")

What's Next?

Now that you have a working calculator with NumPy, you can expand it:

1. Add more objects: asteroids, comets, stars
2. Calculate orbital velocity: it's escape velocity divided by √2
3. Process CSV files: load planet data from files using NumPy
4. Create visualizations: plot escape velocities with matplotlib
5. Simulate trajectories: use NumPy arrays for orbital mechanics

Summary

We went from a simple formula to a full-featured calculator using NumPy. Along the way you learned:

• Why NumPy is preferred for scientific calculations
• How to use scientific notation in Python
• How to create reusable functions
• How to perform vectorized calculations on multiple objects
• How to build interactive scientific programs

Remember - NumPy is the foundation of scientific Python. Master it, and you'll be ready for more advanced libraries like SciPy, Pandas, and Matplotlib.

Good luck calculating escape velocities from different worlds!