app.py

import streamlit as st
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
import streamlit.components.v1 as components

# ===============================
# Streamlit Interface Setup
# ===============================
st.title("Spin Launch & Orbital Attachment Simulation (Animated)")

st.markdown(
    """
    This simulation demonstrates a two‑phase launch:
    
    1. **Spin‑Launch Phase:** A payload is accelerated from an elevated platform.
    2. **Orbital Phase:** At a specified altitude, the payload “docks” with a human‑rated upper stage by
       instantly setting its velocity to that of a circular orbit.
       
    Adjust the parameters on the sidebar and click **Run Simulation**.
    """
)

# Sidebar parameters for simulation:
st.sidebar.header("Simulation Parameters")

# Time and integration parameters:
dt = st.sidebar.number_input("Time Step (s)", min_value=0.01, max_value=1.0, value=0.1, step=0.01)
t_max = st.sidebar.number_input("Total Simulation Time (s)", min_value=100, max_value=5000, value=1000, step=100)

# Launch conditions:
initial_altitude_km = st.sidebar.number_input("Initial Altitude (km)", min_value=1, max_value=100, value=50, step=1)
initial_velocity = st.sidebar.number_input("Initial Velocity (m/s)", min_value=100, max_value=5000, value=1200, step=100)

# Docking/Orbital attachment altitude:
docking_altitude_km = st.sidebar.number_input("Docking Altitude (km)", min_value=1, max_value=500, value=100, step=1)

# Button to run simulation:
run_sim = st.sidebar.button("Run Simulation")

if run_sim:
    st.info("Running simulation... Please wait.")
    # ===============================
    # Physical Constants and Conversions
    # ===============================
    mu = 3.986e14       # Earth's gravitational parameter, m^3/s^2
    R_E = 6.371e6       # Earth's radius, m

    # Convert altitude values from km to m:
    initial_altitude = initial_altitude_km * 1000.0  # initial altitude above Earth's surface (m)
    docking_altitude = docking_altitude_km * 1000.0    # docking altitude above Earth's surface (m)
    r_dock = R_E + docking_altitude                    # docking radius from Earth's center (m)

    # ===============================
    # Initial Conditions for the Simulation
    # ===============================
    # Starting at a point along the x-axis at a radial distance (Earth's radius + initial altitude)
    initial_position = np.array([R_E + initial_altitude, 0.0])
    # Initial velocity is chosen to be radial (pointing outward) at the chosen speed.
    initial_velocity_vec = np.array([initial_velocity, 0.0])

    # ===============================
    # Define the Acceleration Function
    # ===============================
    def acceleration(pos):
        """Compute acceleration due to Earth's gravity at position pos (in m)."""
        r = np.linalg.norm(pos)
        return -mu * pos / r**3

    # ===============================
    # Run the Simulation Loop
    # ===============================
    # We'll record (time, x, y, phase)
    # phase = 1: spin‑launch phase
    # phase = 2: orbital phase (after docking)
    states = []     
    phase = 1
    t = 0.0
    pos = initial_position.copy()
    vel = initial_velocity_vec.copy()
    docking_done = False
    docking_event_time = None
    docking_event_coords = None

    while t < t_max:
        # --- Check for the Docking Event ---
        # When the payload's distance from Earth's center exceeds the docking radius
        # and it's still moving outward, trigger the docking event.
        if phase == 1 and not docking_done and np.linalg.norm(pos) >= r_dock and vel.dot(pos) > 0:
            docking_done = True
            phase = 2  # switch to orbital phase
            r_current = np.linalg.norm(pos)
            # Compute the circular orbital speed at the current radius:
            v_circ = np.sqrt(mu / r_current)
            # For a prograde orbit, choose a tangential (perpendicular) direction:
            tangential_dir = np.array([-pos[1], pos[0]]) / r_current
            vel = v_circ * tangential_dir  # instantaneous burn to circular orbit
            docking_event_time = t
            docking_event_coords = pos.copy()
            st.write(f"**Docking Event:** t = {t:.1f} s, Altitude = {(r_current - R_E)/1000:.1f} km, Circular Speed = {v_circ:.1f} m/s")
        
        # Record the current state: (time, x, y, phase)
        states.append((t, pos[0], pos[1], phase))
        
        # --- Propagate the State (Euler Integration) ---
        a = acceleration(pos)
        pos = pos + vel * dt
        vel = vel + a * dt
        t += dt

    # Convert the recorded states to a NumPy array for easier slicing.
    states = np.array(states)  # columns: time, x, y, phase

    # ===============================
    # Create the Animation Using Matplotlib
    # ===============================
    fig, ax = plt.subplots(figsize=(8, 8))
    ax.set_aspect('equal')
    ax.set_xlabel("x (km)")
    ax.set_ylabel("y (km)")
    ax.set_title("Trajectory: Spin Launch & Orbital Attachment")

    # Draw Earth as a blue circle (Earth's radius in km)
    earth = plt.Circle((0, 0), R_E / 1000, color='blue', alpha=0.3, label="Earth")
    ax.add_artist(earth)

    # Set plot limits to show the trajectory (e.g., up to Earth's radius + 300 km)
    max_extent = (R_E + 300e3) / 1000  # in km
    ax.set_xlim(-max_extent, max_extent)
    ax.set_ylim(-max_extent, max_extent)

    # Initialize the trajectory line and payload marker for animation:
    trajectory_line, = ax.plot([], [], 'r-', lw=2, label="Trajectory")
    payload_marker, = ax.plot([], [], 'ko', markersize=5, label="Payload")
    time_text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=10)

    def init():
        trajectory_line.set_data([], [])
        payload_marker.set_data([], [])
        time_text.set_text('')
        return trajectory_line, payload_marker, time_text

    def update(frame):
        # Update the trajectory with all positions up to the current frame.
        t_val = states[frame, 0]
        x_vals = states[:frame+1, 1] / 1000  # convert m to km
        y_vals = states[:frame+1, 2] / 1000  # convert m to km
        trajectory_line.set_data(x_vals, y_vals)
        # Wrap coordinates in a list so that they are interpreted as sequences:
        payload_marker.set_data([states[frame, 1] / 1000], [states[frame, 2] / 1000])
        time_text.set_text(f"Time: {t_val:.1f} s")
        return trajectory_line, payload_marker, time_text

    # Create the animation. Adjust the interval (ms) for playback speed.
    anim = FuncAnimation(fig, update, frames=len(states), init_func=init, interval=20, blit=True)

    # Convert the animation to an HTML5 video.
    video_html = anim.to_html5_video()

    if video_html:
        st.markdown("### Simulation Animation")
        # Option 1: Use streamlit components to embed the HTML video
        components.html(video_html, height=500)
        # Option 2: Alternatively, use st.markdown (uncomment the following line to try it)
        # st.markdown(video_html, unsafe_allow_html=True)
    else:
        st.error("No video generated. Please ensure that ffmpeg is installed and properly configured.")

    st.markdown(
        """
        **Note:** This is a highly simplified simulation. In a real-world scenario, the spin‑launch, docking, 
        and orbital insertion phases would involve much more complex physics including aerodynamics, non‑instantaneous burns,
        and detailed guidance and control.
        """
    )