Transferencias Interplanetarias con Python

Whoami

Ingeniero aeroespacial interesado en la astrodinámica computacional. Actualmente trabajo como ingeniero senior de I+D en ANSYS, Inc.

Misiones a Marte 2020 – 2021

¿Por qué todas las misiones se lanzan y llegan a Marte al mismo tiempo?

Fundamentos del viaje interplanetario

Primero, debemos resolver las siguientes preguntas:

• ¿Cómo se mueven los cuerpos en el espacio exterior?
• ¿Es posible navegar en el espacio exterior?
• ¿Es posible hacerlo de forma óptima?

Modelo matemático real

Modelo matemático simplificado

¿Dónde obtener datos sobre los planetas?

El JPL de la NASA mantiene un conjunto de efemérides de alta precisión. Las efemérides son tablas o modelos que proporcionan las posiciones y velocidades de los cuerpos celestes a lo largo del tiempo.

• Elaboradas a partir de observaciones astronómicas y datos de misiones espaciales

Kernels de SPICE

Existen varios tipos de kernels:

• LSK: datos de tiempo
• SPK: efemérides de cuerpos celestes
• PCK: datos físicos de cuerpos celestes

Ejemplo: obtener la posición de la Tierra respecto al Sol

import spiceypy as spice

spice.furnsh("latest_leapseconds.tls")
spice.furnsh("de430.bsp")

utc_time = "2025-09-26 00:00:00"
et = spice.str2et(utc_time)

state, light_time = spice.spkezr("EARTH", et, "J2000", "LT+S", "SUN")
position, velocity = state[:3], state[3:]

print(f"Epoch (UTC): {utc_time}")
print(f"Position: {position} [km]")
print(f"Velocity: {velocity} [km]")
print(f"Light time: {light_time:.6f} [s]")

spice.kclear()

Epoch (UTC): 2025-09-26 00:00:00
Position: [1.49823038e+08 6.74792631e+06 2.92466037e+06] [km]
Velocity: [-1.9519849  27.20267832 11.79246548] [km]
Light time: 500.357603 [s]

Órbitas

Los objetos en el espacio están sujetos a la fuerza de gravedad. Esto hace que sigan trayectorias cónicas conocidas como órbitas.

• La forma y orientación están definidas por la posición y velocidad
• La ubicación dentro de la órbita está definida por la época

Tipos de órbitas por geometría

Las órbitas pueden clasificarse según su geometría:

Maniobras impulsivas

Son maniobras que cambian instantáneamente la velocidad de una nave espacial. Esto inserta a la nave espacial en una nueva órbita.

• Transferencia de Hohmann (la órbita objetivo debe ser coplanar)
• Transferencia bi-elliptica (la órbita objetivo debe ser coplanar)
• Transferencia de Lambert

Maniobras impulsivas

Dado que las maniobras impulsivas introducen un \(\Delta v\), es posible calcular el gasto de combustible asociado a la maniobra aplicando la ecuación de Tsiolkovsky.

\[ \Delta v = v_e \ln \left( \frac{m_0}{m_f} \right) \]

El problema de Lambert

Debemos resolver el problema de Lambert para encontrar la órbita entre dos puntos en el espacio.

Un problema muy popular

Algoritmos desarrollados a lo largo de los últimos años:

Resolviendo el problema con Python

Resolviendo el problema con lamberthub

Lamberthub es una librería que contiene un conjunto de algoritmos para resolver el problema de Lambert.

from lamberthub import authorYYYY


v1, v2 = authorYYYY(
    mu, r1, r2, tof, M=0, prograde=True, low_path=True,  # Type of solution
    maxiter=35, atol=1e-5, rtol=1e-7, full_output=False  # Iteration config
)

Las velocidades de lanzamiento y llegada se usan para calcular los impulsos de la de la maniobra.

Navegando entre planetas

Ahora que sabemos cómo resolver el problema de Lambert, podemos planificar un viaje entre planetas.

1. Seleccionar las fechas de lanzamiento y llegada
2. Obtener las posiciones de los planetas en esas fechas
3. Obtener las velocidades de lanzamiento y llegada resolviendo el problema de Lambert
4. Calcular los impulsos necesarios para la maniobra
5. Estimar el combustible necesario

Ejemplo: viaje de la Tierra a Marte

from lamberthub import izzo2015 as lambert
import spiceypy as spice

MU_SUN = 1.32712440018e11  # Gravitational parameter of the Sun in [km^3/s^2]


norm = lambda vector: sum(x**2 for x in vector) ** 0.5
furnsh_kernels = lambda *kernels: list(map(spice.furnsh, kernels))

def get_state_for_body_at_epoch(body, et):
    state, light_time = spice.spkezr(body, et, "J2000", "LT+S", "SSB")
    return state[:3], state[3:], light_time


furnsh_kernels("de430.bsp", "latest_leapseconds.tls", "pck00011.tpc")

departure_time, arrival_time = spice.str2et("2025-01-01 00:00:00"), spice.str2et("2025-03-01 00:00:00")
tof = arrival_time - departure_time

earth_pos, earth_vel, _ = get_state_for_body_at_epoch("EARTH_BARYCENTER", departure_time)
mars_pos, mars_vel, _ = get_state_for_body_at_epoch("MARS_BARYCENTER", arrival_time)

v1, v2 = lambert(MU_SUN, earth_pos, mars_pos, tof)

delta_v1, delta_v2 = abs(norm(v1) - norm(earth_vel)), abs(norm(mars_vel) - norm(v2))

print(f"Delta-v departure: {delta_v1:.2f} [km/s]")
print(f"Delta-v arrival: {delta_v2:.2f} [km/s]")

Delta-v departure: 6.76 [km/s]
Delta-v arrival: 3.02 [km/s]

Resolviendo para varias fechas

¿Y si resolvemos el problema para diferentes combinaciones de fechas de salida y llegada?

Porkchop plots

Mapa de contornos que muestra la energía necesaria para viajar entre dos órbitas en función de las fechas de salida y llegada.

Porkchop plots

Optimización de trayectorias

En misiones complejas, optimizar la trayectoria puede ser complicado. La imagen muestra la trayectoria de la sonda Cassini a Saturno.

Optimización de trayectorias

Existen diversas herramientas para optimizar trayectorias:

Normalmente, los algoritmos se programan en un leguaje compilado y se exponen a través de bindings a Python.