Update app.py

app.py

@@ -1,25 +1,27 @@
 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")
+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 chosen altitude, the payload “docks” with a human‑rated upper stage by
+    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 in the sidebar and click "Run Simulation" to see the result.
+    Adjust the parameters on the sidebar and click **Run Simulation**.
     """
 )
 
-# Sidebar parameters for simulation
+# Sidebar parameters for simulation:
 st.sidebar.header("Simulation Parameters")
 
 # Time and integration parameters:
@@ -33,7 +35,7 @@ initial_velocity = st.sidebar.number_input("Initial Velocity (m/s)", min_value=1
 # 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
+# Button to run simulation:
 run_sim = st.sidebar.button("Run Simulation")
 
 if run_sim:
@@ -60,17 +62,18 @@ if run_sim:
     # Define the Acceleration Function
     # ===============================
     def acceleration(pos):
-        """
-        Compute acceleration due to Earth's gravity at position pos (in m).
-        """
+        """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
     # ===============================
-    states = []  # Will store tuples of (time, x, y, phase)
-    phase = 1    # Phase 1: spin-launch, Phase 2: orbital phase after docking
+    # 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()
@@ -81,68 +84,84 @@ if run_sim:
     while t < t_max:
         # --- Check for the Docking Event ---
         # When the payload's distance from Earth's center exceeds the docking radius
-        # and it is still moving outward (positive radial velocity), we trigger the docking.
+        # 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
+            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 direction (perpendicular to the radial vector):
+            # For a prograde orbit, choose a tangential (perpendicular) direction:
             tangential_dir = np.array([-pos[1], pos[0]]) / r_current
-            vel = v_circ * tangential_dir  # Instantaneously change velocity for orbital insertion
+            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 current state: (time, x, y, phase)
+        # Record the current state: (time, x, y, phase)
         states.append((t, pos[0], pos[1], phase))
         
-        # --- Propagate the state using simple Euler integration ---
+        # --- Propagate the State (Euler Integration) ---
         a = acceleration(pos)
         pos = pos + vel * dt
         vel = vel + a * dt
         t += dt
 
-    # Convert states to a NumPy array for easier slicing:
+    # Convert the recorded states to a NumPy array for easier slicing.
     states = np.array(states)  # columns: time, x, y, phase
 
     # ===============================
-    # Create the Trajectory Plot with Matplotlib
+    # 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 and Orbital Attachment")
+    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)
 
-    # Define plot limits (extend to show orbit, e.g., Earth's radius plus 300 km):
+    # 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)
 
-    # Separate the recorded states into spin-launch and orbital phases:
-    spin_phase = states[states[:, 3] == 1]
-    orbital_phase = states[states[:, 3] == 2]
-
-    # Plot the spin-launch phase in red:
-    if spin_phase.size > 0:
-        ax.plot(spin_phase[:, 1] / 1000, spin_phase[:, 2] / 1000, 'r-', label="Spin‑Launch Phase")
-    # Plot the orbital phase in green:
-    if orbital_phase.size > 0:
-        ax.plot(orbital_phase[:, 1] / 1000, orbital_phase[:, 2] / 1000, 'g-', label="Orbital Phase")
-
-    # Mark the launch start:
-    ax.plot(initial_position[0] / 1000, initial_position[1] / 1000, 'ko', label="Launch Start")
-    # Mark the docking event, if it occurred:
-    if docking_done and docking_event_coords is not None:
-        ax.plot(docking_event_coords[0] / 1000, docking_event_coords[1] / 1000, 'bo', markersize=8, label="Docking Event")
-
-    ax.legend()
-    st.pyplot(fig)
-
-    st.markdown("**Note:** This is a simplified simulation. In a realistic system, the spin‑launch phase, docking maneuver, and orbital insertion would be modeled with far more complexity (including aerodynamic forces, gradual burns, and detailed guidance dynamics).")
+    # 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)
+        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. The interval (in ms) can be adjusted for 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()
+
+    st.markdown("### Simulation Animation")
+    components.html(video_html, height=500)
+
+    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.
+        """
+    )