Create app.py

app.py

@@ -0,0 +1,148 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+
+# ===============================
+# Streamlit Interface Setup
+# ===============================
+st.title("Spin Launch & Orbital Attachment Simulation")
+
+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
+       instantly setting its velocity to that of a circular orbit.
+       
+    Adjust the parameters in the sidebar and click "Run Simulation" to see the result.
+    """
+)
+
+# 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:
+    # ===============================
+    # 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
+    # ===============================
+    states = []  # Will store tuples of (time, x, y, phase)
+    phase = 1    # Phase 1: spin-launch, Phase 2: orbital phase after docking
+    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 is still moving outward (positive radial velocity), we trigger the docking.
+        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 direction (perpendicular to the radial vector):
+            tangential_dir = np.array([-pos[1], pos[0]]) / r_current
+            vel = v_circ * tangential_dir  # Instantaneously change velocity for orbital insertion
+            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)
+        states.append((t, pos[0], pos[1], phase))
+        
+        # --- Propagate the state using simple Euler integration ---
+        a = acceleration(pos)
+        pos = pos + vel * dt
+        vel = vel + a * dt
+        t += dt
+
+    # Convert states to a NumPy array for easier slicing:
+    states = np.array(states)  # columns: time, x, y, phase
+
+    # ===============================
+    # Create the Trajectory Plot with 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")
+
+    # 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):
+    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).")