Create app.py

app.py

@@ -0,0 +1,220 @@
+# Import required libraries
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.interpolate import interp1d
+
+# Constants
+G_EARTH = 9.81  # m/s^2, gravitational acceleration
+R_EARTH = 6371000  # m, Earth's radius
+MU_EARTH = 3.986e14  # m^3/s^2, Earth's gravitational parameter
+R_GAS = 287  # J/(kg·K), specific gas constant for air
+ATM_PRESSURE_SEA = 101325  # Pa, sea-level pressure
+TEMP_SEA = 288.15  # K, sea-level temperature
+LAPSE_RATE = 0.0065  # K/m, temperature lapse rate
+
+# Atmospheric model (simplified ISA)
+def atmospheric_conditions(altitude):
+    temp = TEMP_SEA - LAPSE_RATE * altitude if altitude < 11000 else 216.65
+    pressure = ATM_PRESSURE_SEA * (temp / TEMP_SEA) ** (-G_EARTH / (LAPSE_RATE * R_GAS))
+    density = pressure / (R_GAS * temp)
+    return temp, pressure, density
+
+# Orbital velocity calculation
+def orbital_velocity(altitude):
+    return np.sqrt(MU_EARTH / (R_EARTH + altitude))
+
+# Drag force calculation
+def drag_force(velocity, altitude, diameter, cd=0.3):
+    _, _, rho = atmospheric_conditions(altitude)
+    area = np.pi * (diameter / 2) ** 2
+    return 0.5 * rho * velocity ** 2 * cd * area
+
+# Advanced rocket simulation function
+def simulate_rocket(
+    engine_type, num_engines, isp_vac, thrust_vac, chamber_pressure, nozzle_diameter,
+    structural_material, structural_thickness, diameter, height, staging_enabled,
+    stage1_fuel_mass, stage1_oxidizer_mass, stage2_fuel_mass, stage2_oxidizer_mass,
+    control_system, payload_mass, tank_material, insulation_thickness, target_altitude
+):
+    """
+    Simulate a detailed rocket design with staging, aerodynamics, and thermal effects.
+    
+    Parameters:
+    - engine_type (str): "Liquid", "Solid", "Hybrid"
+    - num_engines (int): Number of engines per stage
+    - isp_vac (float): Specific impulse in vacuum (s)
+    - thrust_vac (float): Thrust per engine in vacuum (N)
+    - chamber_pressure (float): Engine chamber pressure (Pa)
+    - nozzle_diameter (float): Nozzle exit diameter (m)
+    - structural_material (str): "Aluminum", "Titanium", "Composite"
+    - structural_thickness (float): Structural skin thickness (mm)
+    - diameter (float): Rocket diameter (m)
+    - height (float): Total rocket height (m)
+    - staging_enabled (bool): Use two stages if True
+    - stage1_fuel_mass, stage1_oxidizer_mass (float): Propellant masses for stage 1 (kg)
+    - stage2_fuel_mass, stage2_oxidizer_mass (float): Propellant masses for stage 2 (kg)
+    - control_system (str): "Gimbaled", "TVS", "RCS"
+    - payload_mass (float): Payload mass (kg)
+    - tank_material (str): "Aluminum", "Stainless Steel", "Composite"
+    - insulation_thickness (float): Thermal insulation thickness (mm)
+    - target_altitude (float): Desired orbital altitude (m)
+    
+    Returns:
+    - dict: Performance metrics and design feasibility
+    - matplotlib.figure: Radar chart of normalized performance
+    """
+    # Material properties
+    material_density = {"Aluminum": 2700, "Titanium": 4500, "Composite": 1600}  # kg/m^3
+    material_strength = {"Aluminum": 310e6, "Titanium": 950e6, "Composite": 600e6}  # Pa
+    tank_density = {"Aluminum": 2700, "Stainless Steel": 8000, "Composite": 1600}  # kg/m^3
+    
+    # Structural mass calculation
+    surface_area = 2 * np.pi * (diameter / 2) * height + 2 * np.pi * (diameter / 2) ** 2
+    structural_mass = surface_area * (structural_thickness / 1000) * material_density[structural_material]
+    
+    # Tank mass (cylindrical tanks with spherical ends)
+    tank_volume = (stage1_fuel_mass + stage1_oxidizer_mass + stage2_fuel_mass + stage2_oxidizer_mass) / 1000  # m^3
+    tank_surface_area = 4 * np.pi * (diameter / 2) ** 2 + np.pi * diameter * height / 2
+    tank_mass = tank_surface_area * (insulation_thickness / 1000) * tank_density[tank_material]
+    
+    # Total masses
+    stage1_prop_mass = stage1_fuel_mass + stage1_oxidizer_mass
+    stage2_prop_mass = stage2_fuel_mass + stage2_oxidizer_mass
+    stage1_dry_mass = structural_mass * 0.7 + tank_mass * 0.7 + num_engines * 50  # Engine mass ~50 kg each
+    stage2_dry_mass = structural_mass * 0.3 + tank_mass * 0.3 + (num_engines * 50 if staging_enabled else 0)
+    total_mass_initial = stage1_dry_mass + stage1_prop_mass + stage2_dry_mass + stage2_prop_mass + payload_mass
+    
+    # Thrust and ISP at sea level
+    isp_sea = isp_vac * (1 - (ATM_PRESSURE_SEA / chamber_pressure) * (nozzle_diameter / diameter) ** 2)
+    thrust_sea = thrust_vac * (isp_sea / isp_vac)
+    total_thrust_sea = num_engines * thrust_sea
+    
+    # Check lift-off capability
+    twr_sea = total_thrust_sea / (total_mass_initial * G_EARTH)
+    if twr_sea <= 1.1:  # Minimum TWR for lift-off with margin
+        return {"error": "Insufficient thrust for lift-off"}, plt.figure(figsize=(6, 6))
+    
+    # Delta-v calculation with staging
+    if staging_enabled:
+        delta_v1 = isp_vac * G_EARTH * np.log((stage1_dry_mass + stage1_prop_mass + stage2_dry_mass + stage2_prop_mass + payload_mass) / 
+                                               (stage1_dry_mass + stage2_dry_mass + stage2_prop_mass + payload_mass))
+        delta_v2 = isp_vac * G_EARTH * np.log((stage2_dry_mass + stage2_prop_mass + payload_mass) / 
+                                              (stage2_dry_mass + payload_mass))
+        total_delta_v = delta_v1 + delta_v2
+    else:
+        total_delta_v = isp_vac * G_EARTH * np.log(total_mass_initial / (structural_mass + tank_mass + payload_mass))
+    total_delta_v /= 1000  # Convert to km/s
+    
+    # Orbital requirement
+    v_orbit = orbital_velocity(target_altitude) / 1000  # km/s
+    orbit_capable = total_delta_v >= v_orbit + 1.5  # 1.5 km/s margin for losses
+    
+    # Structural integrity (stress analysis)
+    max_pressure = chamber_pressure * 1.5  # Safety factor
+    hoop_stress = max_pressure * (diameter / 2) / (structural_thickness / 1000)
+    structural_integrity = min(100, 100 * (material_strength[structural_material] / hoop_stress))
+    
+    # Aerodynamic drag losses (simplified)
+    avg_velocity = total_delta_v * 1000 / 10  # m/s, rough ascent average
+    drag_loss = drag_force(avg_velocity, target_altitude / 2, diameter) / (total_mass_initial * G_EARTH) * 100  # km/s
+    
+    # Thermal protection adequacy
+    reentry_heat_flux = 50000 * (target_altitude / 200000) ** 0.5  # W/m^2, simplified
+    insulation_effectiveness = insulation_thickness / 10  # Arbitrary scaling
+    thermal_score = min(100, 100 * insulation_effectiveness / (reentry_heat_flux / 10000))
+    
+    # Cost estimation
+    cost = (structural_mass * {"Aluminum": 50, "Titanium": 150, "Composite": 200}[structural_material] +
+            tank_mass * {"Aluminum": 40, "Stainless Steel": 60, "Composite": 180}[tank_material] +
+            num_engines * 200000 + payload_mass * 100)
+    
+    # Stability based on control system
+    stability = {"Gimbaled": 90, "TVS": 80, "RCS": 70}[control_system]
+    
+    # Output dictionary
+    results = {
+        "Delta-v (km/s)": f"{total_delta_v:.2f}",
+        "TWR (Sea Level)": f"{twr_sea:.2f}",
+        "Structural Integrity (%)": f"{structural_integrity:.1f}",
+        "Cost ($)": f"{cost:.2f}",
+        "Stability (%)": f"{stability}",
+        "Orbit Capable": "Yes" if orbit_capable else "No",
+        "Thermal Protection (%)": f"{thermal_score:.1f}",
+        "Drag Loss (km/s)": f"{drag_loss:.2f}"
+    }
+    
+    # Radar chart
+    metrics = [total_delta_v / 15, twr_sea / 5, structural_integrity / 100, stability / 100, thermal_score / 100]
+    labels = ["Delta-v", "TWR", "Integrity", "Stability", "Thermal"]
+    angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()
+    metrics += metrics[:1]
+    angles += angles[:1]
+    
+    fig = plt.figure(figsize=(6, 6))
+    ax = fig.add_subplot(111, polar=True)
+    ax.fill(angles, metrics, alpha=0.25)
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(labels)
+    ax.set_title("Rocket Performance Profile")
+    
+    return results, fig
+
+# Gradio interface
+with gr.Blocks(title="Advanced Rocket Design Simulator") as app:
+    gr.Markdown(
+        """
+        # Advanced Rocket Design Simulator
+        Design a rocket with detailed engineering parameters. This tool simulates performance metrics
+        considering aerodynamics, staging, thermal effects, and structural integrity. Adjust inputs
+        to create a feasible design for your target altitude.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Rocket Configuration")
+            engine_type = gr.Dropdown(choices=["Liquid", "Solid", "Hybrid"], value="Liquid", label="Engine Type")
+            num_engines = gr.Slider(1, 10, value=2, step=1, label="Number of Engines")
+            isp_vac = gr.Slider(250, 450, value=320, step=5, label="ISP (Vacuum, s)")
+            thrust_vac = gr.Slider(50000, 2000000, value=500000, step=10000, label="Thrust (Vacuum, N)")
+            chamber_pressure = gr.Slider(1e6, 20e6, value=7e6, step=1e5, label="Chamber Pressure (Pa)")
+            nozzle_diameter = gr.Slider(0.1, 2.0, value=0.5, step=0.05, label="Nozzle Diameter (m)")
+            
+            structural_material = gr.Dropdown(choices=["Aluminum", "Titanium", "Composite"], value="Aluminum", label="Structural Material")
+            structural_thickness = gr.Slider(1, 20, value=5, step=0.5, label="Structural Thickness (mm)")
+            diameter = gr.Slider(1, 10, value=3, step=0.1, label="Rocket Diameter (m)")
+            height = gr.Slider(5, 50, value=20, step=1, label="Rocket Height (m)")
+            
+            staging_enabled = gr.Checkbox(label="Enable Two-Stage Design", value=False)
+            stage1_fuel_mass = gr.Slider(100, 5000, value=2000, step=50, label="Stage 1 Fuel Mass (kg)")
+            stage1_oxidizer_mass = gr.Slider(100, 5000, value=2000, step=50, label="Stage 1 Oxidizer Mass (kg)")
+            stage2_fuel_mass = gr.Slider(0, 2000, value=500, step=50, label="Stage 2 Fuel Mass (kg)")
+            stage2_oxidizer_mass = gr.Slider(0, 2000, value=500, step=50, label="Stage 2 Oxidizer Mass (kg)")
+            
+            control_system = gr.Dropdown(choices=["Gimbaled", "TVS", "RCS"], value="Gimbaled", label="Control System")
+            payload_mass = gr.Slider(10, 1000, value=200, step=10, label="Payload Mass (kg)")
+            tank_material = gr.Dropdown(choices=["Aluminum", "Stainless Steel", "Composite"], value="Aluminum", label="Tank Material")
+            insulation_thickness = gr.Slider(1, 50, value=10, step=1, label="Insulation Thickness (mm)")
+            target_altitude = gr.Slider(100000, 2000000, value=400000, step=10000, label="Target Altitude (m)")
+        
+        with gr.Column():
+            gr.Markdown("### Performance Metrics")
+            outputs = gr.JSON(label="Design Results")
+            radar_plot = gr.Plot(label="Performance Profile")
+    
+    # Inputs list
+    inputs = [
+        engine_type, num_engines, isp_vac, thrust_vac, chamber_pressure, nozzle_diameter,
+        structural_material, structural_thickness, diameter, height, staging_enabled,
+        stage1_fuel_mass, stage1_oxidizer_mass, stage2_fuel_mass, stage2_oxidizer_mass,
+        control_system, payload_mass, tank_material, insulation_thickness, target_altitude
+    ]
+    
+    # Event handling
+    app.load(fn=simulate_rocket, inputs=inputs, outputs=[outputs, radar_plot])
+    for input_component in inputs:
+        input_component.change(fn=simulate_rocket, inputs=inputs, outputs=[outputs, radar_plot])
+
+# Launch the app
+app.launch()