Update app.py

app.py

@@ -1,220 +1,193 @@
-# 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
+# Constants and helper functions (same as before)
+G_EARTH = 9.81
+R_EARTH = 6371000
+MU_EARTH = 3.986e14
+R_GAS = 287
+ATM_PRESSURE_SEA = 101325
+TEMP_SEA = 288.15
+LAPSE_RATE = 0.0065
 
-# 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
+material_density = {"Aluminum": 2700, "Titanium": 4500, "Composite": 1600}
+material_strength = {"Aluminum": 310e6, "Titanium": 950e6, "Composite": 600e6}
+tank_density = {"Aluminum": 2700, "Stainless Steel": 8000, "Composite": 1600}
+
+cost_factors = {
+    "engines": 200000,
+    "structural_material": {"Aluminum": 50, "Titanium": 150, "Composite": 200},
+    "tank_material": {"Aluminum": 40, "Stainless Steel": 60, "Composite": 180},
+    "payload": 100
+}
+
+# Simulate rocket function (placeholder, same as before)
 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
+    return {
+        "Delta-v (km/s)": "10.0 km/s",
+        "TWR (Sea Level)": "1.5",
+        "Structural Integrity (%)": "85",
+        "Cost ($)": "$1000000"
+    }, plt.figure()
+
+# Optimization function with multiple goals and constraints
+def optimize_design(
+    delta_v_goal, twr_goal, integrity_goal, cost_goal,
+    payload_mass, structural_material, control_system, target_altitude,
+    max_engines, max_thickness, staging_enabled
+):
+    # Define design space
+    engine_types = ["Liquid", "Solid", "Hybrid"]
+    num_engines_options = range(1, max_engines + 1)
+    isp_options = [250, 300, 350, 400]
+    thrust_options = [100000, 200000, 500000, 1000000]
+    structural_thickness_options = [t for t in [2, 5, 10, 15] if t <= max_thickness]
+    
+    best_design = None
+    best_score = -float('inf')
+    best_metrics = {}
+    
+    for engine_type in engine_types:
+        for num_engines in num_engines_options:
+            for isp in isp_options:
+                for thrust in thrust_options:
+                    for thickness in structural_thickness_options:
+                        # Calculate design metrics
+                        chamber_pressure = 7e6
+                        nozzle_diameter = 0.5
+                        diameter = 3
+                        height = 20
+                        stage1_fuel_mass = 2000 if staging_enabled else 4000
+                        stage1_oxidizer_mass = 2000 if staging_enabled else 4000
+                        stage2_fuel_mass = 500 if staging_enabled else 0
+                        stage2_oxidizer_mass = 500 if staging_enabled else 0
+                        tank_material = "Aluminum"
+                        insulation_thickness = 10
+                        
+                        results, _ = simulate_rocket(
+                            engine_type, num_engines, isp, thrust, chamber_pressure, nozzle_diameter,
+                            structural_material, 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
+                        )
+                        
+                        if "error" not in results:
+                            delta_v = float(results["Delta-v (km/s)"].split()[0])
+                            twr = float(results["TWR (Sea Level)"].split()[0])
+                            integrity = float(results["Structural Integrity (%)"])
+                            cost = float(results["Cost ($)"].replace("$", "").replace(",", ""))
+                            
+                            # Check constraints (example thresholds for now)
+                            if twr > 1.1 and integrity >= 80:
+                                # Calculate score based on goals
+                                # Simple scoring: minimize deviation from goals
+                                delta_v_diff = abs(delta_v - delta_v_goal) / 15  # Normalize
+                                twr_diff = max(0, twr_goal - twr) / 2  # Normalize, penalize if below goal
+                                integrity_diff = max(0, integrity_goal - integrity) / 100  # Normalize
+                                cost_diff = max(0, cost - cost_goal) / 10000000  # Normalize
+                                score = -(delta_v_diff + twr_diff + integrity_diff + cost_diff)
+                                
+                                if score > best_score:
+                                    best_score = score
+                                    best_design = {
+                                        "Engine Type": engine_type,
+                                        "Num Engines": num_engines,
+                                        "ISP": isp,
+                                        "Thrust": thrust,
+                                        "Thickness": thickness,
+                                        "Staging": staging_enabled
+                                    }
+                                    best_metrics = results
+    
+    if best_design:
+        return best_design, best_metrics
     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
+        return "No feasible design found", {}
 
 # Gradio interface
-with gr.Blocks(title="Advanced Rocket Design Simulator") as app:
+with gr.Blocks(title="Rocket Design Optimizer") 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.
+        # Rocket Design Optimizer
+        Define your design goals (desired performance metrics) and constraints, and the app will find the optimal rocket design.
         """
     )
     
     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)")
+            gr.Markdown("### Design Goals (Performance Metrics)")
+            delta_v_goal = gr.Slider(5, 15, value=10, label="Delta-v Goal (km/s)")
+            twr_goal = gr.Slider(1.1, 2.0, value=1.5, label="TWR Goal (Sea Level)")
+            integrity_goal = gr.Slider(80, 100, value=85, label="Structural Integrity Goal (%)")
+            cost_goal = gr.Slider(100000, 10000000, value=5000000, label="Cost Goal ($)")
         
         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
-    ]
+            gr.Markdown("### Constraints")
+            payload_mass = gr.Slider(10, 1000, value=200, label="Payload Mass (kg)")
+            structural_material = gr.Dropdown(choices=["Aluminum", "Titanium", "Composite"], value="Aluminum", label="Structural Material")
+            control_system = gr.Dropdown(choices=["Gimbaled", "TVS", "RCS"], value="Gimbaled", label="Control System")
+            target_altitude = gr.Slider(100000, 2000000, value=400000, label="Target Altitude (m)")
+            max_engines = gr.Slider(1, 4, value=4, label="Max Number of Engines")
+            max_thickness = gr.Slider(2, 15, value=15, label="Max Structural Thickness (mm)")
+            staging_enabled = gr.Checkbox(value=True, label="Enable Staging")
     
-    # 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])
+    with gr.Row():
+        optimize_button = gr.Button("Optimize Design")
+        design_output = gr.JSON(label="Optimized Design Parameters")
+        performance_output = gr.JSON(label="Performance Metrics")
+        radar_plot = gr.Plot(label="Performance Profile")
+    
+    def run_optimization(
+        delta_v_goal, twr_goal, integrity_goal, cost_goal,
+        payload_mass, structural_material, control_system, target_altitude,
+        max_engines, max_thickness, staging_enabled
+    ):
+        design, metrics = optimize_design(
+            delta_v_goal, twr_goal, integrity_goal, cost_goal,
+            payload_mass, structural_material, control_system, target_altitude,
+            max_engines, max_thickness, staging_enabled
+        )
+        if design == "No feasible design found":
+            return design, {}, plt.figure()
+        else:
+            # Simulate the design to get full metrics
+            results, fig = simulate_rocket(
+                design["Engine Type"], design["Num Engines"], design["ISP"], design["Thrust"], 7e6, 0.5,
+                structural_material, design["Thickness"], 3, 20, staging_enabled,
+                2000 if staging_enabled else 4000, 2000 if staging_enabled else 4000,
+                500 if staging_enabled else 0, 500 if staging_enabled else 0,
+                control_system, payload_mass, "Aluminum", 10, target_altitude
+            )
+            return design, metrics, fig
+    
+    optimize_button.click(
+        fn=run_optimization,
+        inputs=[
+            delta_v_goal, twr_goal, integrity_goal, cost_goal,
+            payload_mass, structural_material, control_system, target_altitude,
+            max_engines, max_thickness, staging_enabled
+        ],
+        outputs=[design_output, performance_output, radar_plot]
+    )
 
-# Launch the app
 app.launch()