A 2D Earth–Moon orbital flight simulation written in Python using numerical integration and event-driven mission phases.
This project simulates a multi-stage launch vehicle from liftoff, orbital insertion, translunar injection (TLI), and lunar transfer coast using custom physics, guidance, and mission sequencing systems.
This simulator was built to explore orbital mechanics, launch guidance, and translunar mission planning from the ground up without relying on external aerospace simulation engines.
The simulation includes:
- Multi-stage launch vehicle dynamics
- Earth and Moon gravity
- Atmospheric drag
- Open-loop ascent guidance
- PEG-inspired orbital insertion guidance
- Translunar Injection (TLI)
- Dynamic launch window targeting
- Event-driven mission phases
- Numerical orbit propagation using SciPy
The project started as a launch/orbit sandbox and gradually evolved into a larger orbital mission framework.
- Multi-stage rocket support
- Wet/dry mass tracking
- Stage separation
- Variable thrust and ISP per stage
- Mass flow simulation
STAGES = [
{'name': 'Stage 1', 'm_wet': 2214e3, 'm_dry': 13e3, 'thrust': 33e6, 'isp': 250},
{'name': 'Stage 2', 'm_wet': 470e3, 'm_dry': 43e3, 'thrust': 44e5, 'isp': 420},
{'name': 'Stage 3', 'm_wet': 1205e2, 'm_dry': 152e2, 'thrust': 1e6, 'isp': 421},
]
- Newtonian gravity
- Two-body and Earth–Moon interactions
- Elliptical Moon orbit
- Orbital energy calculations
- Apoapsis/periapsis estimation
- Atmospheric density interpolation from real data
- Aerodynamic drag calculations
- Dynamic velocity losses during ascent
The launch vehicle performs a gravity turn using configurable pitch shaping. With parameters for pitch start, ascent path, final booster angle and such.
A PEG-inspired guidance mode attempts to circularize into Low Earth Orbit.
The simulation computes launch timing windows and performs a continuous prograde burn until the transfer trajectory reaches lunar distance.
Early mission planning, transfer geometry calculations, and guidance experimentation were initially prototyped on whiteboard/paper before implementation.
|
|
|
The mission is organized into flexible event-driven phases, which can be freely modified:
- Liftoff
- Ascent
- Stage Separation
- Orbital Insertion
- Parking Orbit Coast
- TLI Window Alignment
- Translunar Injection Burn
- Lunar Transfer Coast
mission_phases = [
{'name': 'Liftoff', 'mode': 'burn', 'stage': 0, 'end': 'altitude', 'value': booster_pitch_start},
{'name': 'Ascent', 'mode': 'burn', 'stage': 0, 'end': 'burnout', 'value': None},
{'name': 'Stage 2', 'mode': 'burn', 'stage': 1, 'end': 'burnout', 'value': None},
{'name': 'Stage 3 LEO', 'mode': 'burn', 'stage': 2, 'end': 'orbit', 'value': None},
{'name': 'Coast', 'mode': 'coast', 'stage': 2, 'end': 'duration', 'value': 4000},
{'name': 'LEO Coast', 'mode': 'coast', 'stage': 2, 'end': 'luna_in_place', 'value': None},
{'name': 'LEO Coast Window', 'mode': 'coast', 'stage': 2, 'end': 'tli_window', 'value': None},
{'name': 'TLI Burn', 'mode': 'burn', 'stage': 2, 'end': 'tli', 'value': None},
{'name': 'TLI Coast', 'mode': 'coast', 'stage': 2, 'end': 'altitude', 'value': luna_per},
{'name': 'Luna Orbit Coast', 'mode': 'coast', 'stage': 2, 'end': 'duration', 'value': 40000},
]
The simulator numerically integrates motion using:
F = m * a
and Newtonian gravity:
F = G * ( m1 * m2 / r ^ 2 )
Orbital Velocity / Vis-Viva Equation
v = sqrt( mu * (2/r - 1/a))
Kepler’s Third Law:
T = 2pi * sqrt( a^3/mu )
Rocket Equation (Tsiolkovsky):
dv = Isp * g0 * ln( m0/mt )
The equations of motion are propagated using:
scipy.integrate.solve_ivp
LSODA adaptive solver
- Python
- NumPy
- SciPy
- Matplotlib
orbital_simulation/
├── main.py
├── earth_atmosphere_density.txt
└── README.md
Future versions will split the project into:
- physics modules
- guidance systems
- targeting utilities
- visualization tools
- mission configuration files
This project is still under active development and currently uses several approximations:
- Simplified 2D orbital plane
- No true patched-conic sphere-of-influence transitions
- Simplified Moon transfer targeting
- No full n-body propagation
- Guidance algorithms are still experimental
- Lunar orbit insertion is not yet implemented
Despite these simplifications, the simulation produces stable launch, orbit insertion, and translunar transfer behavior suitable for experimentation and visualization.
Planned upgrades include:
- Patched conics
- Lunar sphere-of-influence transitions
- Real lunar capture/orbit insertion
- Improved PEG guidance
- Orbital element utilities
- Config system and GUI launcher
- Better telemetry and plotting
- Real-time visualization
- 3D simulation support
- Numerical optimization for transfer targeting
pip install numpy scipy matplotlib
python Main.py
This project was created as a personal engineering and physics challenge to better understand:
- orbital mechanics
- launch dynamics
- numerical integration
- spacecraft guidance
- mission sequencing
- aerospace simulation architecture
Most of the systems were implemented manually from first principles rather than using existing aerospace frameworks.
- https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html
- https://icas.org/icas_archive/ICAS2012/PAPERS/611.PDF
- https://ntrs.nasa.gov/api/citations/20250008278/downloads/PEG_ASC25_Mahajan.pdf
- https://www.mdpi.com/2226-4310/12/1/61
- https://www.youtube.com/watch?v=HE3a_bmEHyo
- https://www.youtube.com/watch?v=9mmmHaOfyco