Update app.py

app.py

@@ -1,432 +1,390 @@
-import gradio as gr
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import plotly.graph_objects as go
-import plotly.express as px
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.preprocessing import StandardScaler
-import warnings
-warnings.filterwarnings('ignore')
-
-# Materials database
-def load_materials_database():
-    return pd.DataFrame({
-        'Material': ['Steel 1045', 'Steel 4140', 'Aluminum 6061-T6', 'Aluminum 7075-T6', 
-                    'Stainless 304', 'Titanium Ti-6Al-4V', 'Cast Iron GG20', 'Brass C360'],
-        'Density (kg/m³)': [7850, 7850, 2700, 2810, 8000, 4430, 7200, 8500],
-        'Yield Strength (MPa)': [310, 415, 276, 503, 205, 880, 250, 125],
-        'Ultimate Strength (MPa)': [565, 655, 310, 572, 515, 950, 350, 315],
-        'Elastic Modulus (GPa)': [200, 205, 69, 72, 200, 114, 100, 100],
-        'Cost ($/kg)': [0.80, 1.20, 1.90, 2.50, 3.50, 35.00, 0.60, 6.50],
-        'Temperature Limit (°C)': [400, 500, 200, 180, 800, 600, 350, 250]
-    })
-
-materials_db = load_materials_database()
-
-# AI Knowledge Base
-def get_ai_response(query):
-    responses = {
-        "material": "For material selection, consider strength requirements, environmental conditions, cost, and manufacturability. Steel offers good strength at low cost, aluminum provides excellent strength-to-weight ratio, and stainless steel offers superior corrosion resistance.",
-        "design": "Design optimization involves balancing performance, cost, and manufacturability. Apply DFMA principles, minimize stress concentrations, and use appropriate safety factors. Consider topology optimization for weight reduction.",
-        "stress": "Stress analysis requires proper load identification, material properties, and boundary conditions. Use von Mises criterion for ductile materials and maximum principal stress for brittle materials. Include safety factors based on application criticality.",
-        "failure": "Failure prediction involves monitoring key parameters and applying appropriate failure theories. Consider fatigue, wear, corrosion, and overload failure modes. Implement condition-based monitoring for early detection.",
-        "gear": "Gear design requires consideration of power transmission, speed ratio, center distance, and material selection. Use Lewis equation for bending stress and Hertz equation for contact stress.",
-        "beam": "Beam analysis involves calculating bending moments, shear forces, and deflections. For simply supported beams: σ_max = Mc/I, δ_max = 5wL⁴/384EI (uniform load)."
-    }
-    
-    query_lower = query.lower()
-    for key, response in responses.items():
-        if key in query_lower:
-            return response
-    return "I can help with material selection, design optimization, stress analysis, failure prediction, gear design, and beam analysis. Please specify your engineering question."
-
-# 3D Model Generation
-def generate_3d_model(component, teeth=20, module=2, length=100, diameter=20):
-    if component == "Gear":
-        # Generate gear profile
-        angles = np.linspace(0, 2*np.pi, teeth*4)
-        radius = teeth * module / 2
-        r_vals = []
-        for i, angle in enumerate(angles):
-            if i % 4 < 2:  # Tooth
-                r_vals.append(radius + module)
-            else:  # Root
-                r_vals.append(radius - module)
-        
-        x = np.array(r_vals) * np.cos(angles)
-        y = np.array(r_vals) * np.sin(angles)
-        
+!apt-get update -qq
+!apt-get install -y -qq gmsh
+!pip install torch --upgrade -q
+!pip install --upgrade -q \
+    gmsh \
+    meshio \
+    trimesh \
+    numpy \
+    pandas \
+    scikit-learn \
+    matplotlib \
+    plotly \
+    ipywidgets \
+    gradio
+!pip install --upgrade -q jax jaxlib
+
+# ===== CELL 1: SYSTEM INSTALLATION (RUN THIS FIRST) =====
+# It is recommended to use the separate, more robust dependency installation
+# script provided previously. This cell is a simplified version.
+import subprocess
+import sys
+import os
+
+def install_dependencies():
+    """Installs all necessary system and Python packages for Colab."""
+    print("🚀 Starting installation...")
+    try:
+        # Step 1: Install system packages like GMSH
+        print("🔧 Installing system package: GMSH...")
+        subprocess.run(["apt-get", "update", "-qq"], check=True, capture_output=True)
+        subprocess.run(["apt-get", "install", "-y", "-qq", "gmsh"], check=True, capture_output=True)
+        print("   ✅ GMSH installed.")
+
+        # Step 2: Install PyTorch and PyTorch Geometric correctly
+        print("\n🧠 Installing PyTorch & PyTorch Geometric...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "torch", "-q"])
+        # This command is crucial as it fetches the correct PyG versions
+        pyg_install_command = [
+            sys.executable, "-m", "pip", "install",
+            "torch-scatter", "torch-sparse", "torch-cluster", "torch-spline-conv", "torch-geometric",
+            "-f", f"https://data.pyg.org/whl/torch-{subprocess.check_output([sys.executable, '-c', 'import torch; print(torch.__version__)']).decode().strip()}.html",
+            "-q"
+        ]
+        subprocess.check_call(pyg_install_command)
+        print("   ✅ PyTorch & PyG installed.")
+
+        # Step 3: Install other core packages
+        print("\n📦 Installing core libraries...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade",
+                               "gmsh", "meshio", "trimesh", "numpy", "pandas",
+                               "scikit-learn", "matplotlib", "plotly", "ipywidgets", "gradio", "-q"])
+        print("   ✅ Core libraries installed.")
+
+        print("\n🎉 Installation complete! Please restart the runtime and run the next cell.")
+
+    except Exception as e:
+        print(f"❌ An error occurred during installation: {e}")
+        print("   Please check the error message and try again.")
+
+# Run installation
+# install_dependencies()
+
+
+# ===== CELL 2: MAIN APPLICATION (RUN AFTER RESTART) =====
+
+# Safe imports with fallbacks
+def safe_import():
+    """Safely import all required packages after installation."""
+    global gmsh, np, torch, nn, F, Data, GCNConv, pyg_utils, meshio, go, plt, pd, widgets, gr
+    print("🔬 Importing necessary libraries...")
+    try:
+        import numpy as np
+        import pandas as pd
+        import matplotlib.pyplot as plt
+
+        # Mesh and geometry
+        import gmsh
+        import meshio
+
+        # PyTorch and PyTorch Geometric
+        import torch
+        import torch.nn as nn
+        import torch.nn.functional as F
+        from torch_geometric.data import Data
+        from torch_geometric.nn import GCNConv
+        import torch_geometric.utils as pyg_utils
+
+        # Visualization
+        import plotly.graph_objects as go
+
+        # UI/UX
+        import gradio as gr
+        import ipywidgets as widgets
+        from IPython.display import display, clear_output
+
+        import warnings
+        warnings.filterwarnings('ignore')
+
+        print("✅ All packages imported successfully!")
+        return True
+
+    except ImportError as e:
+        print(f"❌ Critical import failure: {e}")
+        print("   Please ensure Cell 1 was run and the runtime was restarted.")
+        return False
+    except Exception as e:
+        print(f"❌ An unexpected error occurred during import: {e}")
+        return False
+
+
+# Import all packages
+if not safe_import():
+    # Stop execution if imports fail
+    sys.exit("Stopping due to import errors.")
+
+
+# ===== STEP 1: MESH GENERATION =====
+print("\n🔧 Step 1: Mesh generation and processing")
+
+def create_beam_geometry(length=10.0, width=1.0, height=2.0, mesh_size=0.5):
+    """Create a 3D beam geometry using GMSH."""
+    try:
+        gmsh.initialize()
+        gmsh.model.add("cantilever_beam")
+        beam = gmsh.model.occ.addBox(0, 0, 0, length, width, height)
+        gmsh.model.occ.synchronize()
+        gmsh.option.setNumber("Mesh.CharacteristicLengthMin", mesh_size * 0.5)
+        gmsh.option.setNumber("Mesh.CharacteristicLengthMax", mesh_size)
+        gmsh.model.mesh.generate(3)
+        gmsh.write("beam_mesh.msh")
+        gmsh.finalize()
+        print(f"✅ GMSH geometry created ('beam_mesh.msh')")
+        return "beam_mesh.msh"
+    except Exception as e:
+        print(f"❌ GMSH geometry creation failed: {e}. Using a fallback mesh.")
+        return create_fallback_mesh()
+
+def create_fallback_mesh():
+    """Create a simple fallback mesh if GMSH fails."""
+    print("🔄 Creating a fallback cubic mesh...")
+    points = np.array([
+        [0, 0, 0], [10, 0, 0], [10, 1, 0], [0, 1, 0],
+        [0, 0, 2], [10, 0, 2], [10, 1, 2], [0, 1, 2]
+    ], dtype=np.float32)
+    cells = [("hexahedron", np.array([[0, 1, 2, 3, 4, 5, 6, 7]]))]
+    mesh = meshio.Mesh(points, cells)
+    mesh.write("fallback_mesh.vtk")
+    print("✅ Fallback mesh created ('fallback_mesh.vtk')")
+    return "fallback_mesh.vtk"
+
+mesh_file = create_beam_geometry()
+
+
+# ===== STEP 2: MESH TO GRAPH CONVERSION =====
+print("\n🔄 Step 2: Converting mesh to graph representation")
+
+def mesh_to_graph(mesh_file):
+    """Convert a mesh file to a PyTorch Geometric graph."""
+    try:
+        mesh = meshio.read(mesh_file)
+        points = mesh.points.astype(np.float32)
+
+        cells = mesh.get_cells_type("tetra")
+        if len(cells) == 0:
+            cells = mesh.get_cells_type("triangle")
+            if len(cells) == 0:
+                hex_cells = mesh.get_cells_type("hexahedron")
+                temp_cells = []
+                for h in hex_cells:
+                    temp_cells.extend([[h[0],h[1],h[2],h[4]],[h[1],h[2],h[3],h[7]]])
+                cells = np.array(temp_cells)
+
+        # ----- MAJOR FIX HERE -----
+        # The function `face_to_edge_index` was removed from torch_geometric.
+        # This is the modern, correct way to compute the edge index from faces.
+        # We get all edges from the faces and then make the graph undirected.
+        faces_tensor = torch.tensor(cells[:, :3].T, dtype=torch.long)
+        edge_index = torch.cat([
+            faces_tensor[[0, 1]], faces_tensor[[1, 2]], faces_tensor[[2, 0]]
+        ], dim=1)
+        edge_index = pyg_utils.to_undirected(edge_index)
+        # ----- END OF FIX -----
+
+        coords = torch.tensor(points, dtype=torch.float32)
+        centroid = coords.mean(dim=0)
+        dist_to_centroid = torch.norm(coords - centroid, dim=1, keepdim=True)
+        coords_normalized = (coords - centroid) / (coords.std(dim=0) + 1e-8)
+        x = torch.cat([coords_normalized, dist_to_centroid], dim=1)
+
+        graph = Data(x=x, edge_index=edge_index, pos=coords)
+        print(f"✅ Graph created: {graph.num_nodes} nodes, {graph.num_edges} edges")
+        return graph, points, cells
+
+    except Exception as e:
+        print(f"❌ Mesh conversion failed: {e}. Cannot proceed.")
+        return None, None, None
+
+graph, points, cells = mesh_to_graph(mesh_file)
+if graph is None:
+    sys.exit("Stopping due to mesh processing errors.")
+
+
+# ===== STEP 3: ACCURATE PHYSICS-BASED ANALYSIS (FEM) =====
+print("\n⚛️  Step 3: Defining accurate physics-based analysis model")
+
+def cantilever_beam_fem(points, E=210e9, load_magnitude=-1000):
+    """Calculates displacement and stress for a cantilever beam using analytical formulas."""
+    length = points[:, 0].max()
+    height = points[:, 2].max()
+    width = points[:, 1].max()
+    I = (width * height**3) / 12
+
+    fixed_nodes = np.where(points[:, 0] < 1e-6)[0]
+    loaded_nodes = np.where(points[:, 0] > length - 1e-6)[0]
+
+    displacement = np.zeros_like(points)
+    stress = np.zeros(len(points))
+    P = -load_magnitude
+
+    for i in range(len(points)):
+        x, _, z = points[i]
+        deflection = (P * x**2) / (6 * E * I) * (3 * length - x)
+        displacement[i, 2] = deflection
+        moment = P * (length - x)
+        z_from_neutral_axis = z - (height / 2)
+        stress[i] = (moment * z_from_neutral_axis) / I
+
+    return displacement, stress, fixed_nodes, loaded_nodes
+
+
+# ===== STEP 4: AI SURROGATE MODEL & LIVE TRAINING =====
+print("\n🧠 Step 4: Building and training AI surrogate model")
+
+class EnhancedSurrogateNet(nn.Module):
+    def __init__(self, in_channels=4, hidden_channels=64, out_channels=4, num_layers=3):
+        super().__init__()
+        self.convs = nn.ModuleList()
+        self.batch_norms = nn.ModuleList()
+        self.convs.append(GCNConv(in_channels, hidden_channels))
+        self.batch_norms.append(nn.BatchNorm1d(hidden_channels))
+        for _ in range(num_layers - 2):
+            self.convs.append(GCNConv(hidden_channels, hidden_channels))
+            self.batch_norms.append(nn.BatchNorm1d(hidden_channels))
+        self.convs.append(GCNConv(hidden_channels, out_channels))
+        self.dropout = nn.Dropout(0.2)
+
+    def forward(self, data):
+        x, edge_index = data.x, data.edge_index
+        for i in range(len(self.convs) - 1):
+            x = self.convs[i](x, edge_index)
+            if x.shape[0] > 1:
+                x = self.batch_norms[i](x)
+            x = F.relu(x)
+            x = self.dropout(x)
+        x = self.convs[-1](x, edge_index)
+        return x
+
+def train_surrogate_model(model, graph_data, training_status_callback):
+    """Trains the surrogate model on synthetically generated data."""
+    print("🚀 Starting AI model training...")
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
+    loss_fn = nn.MSELoss()
+    training_data = []
+    load_scenarios = np.linspace(-500, -5000, 10)
+    for load in load_scenarios:
+        disp_fem, stress_fem, _, _ = cantilever_beam_fem(points, load_magnitude=load)
+        target = torch.tensor(np.hstack([disp_fem, stress_fem[:, np.newaxis]]), dtype=torch.float32)
+        training_data.append(target)
+
+    model.train()
+    for epoch in range(100):
+        total_loss = 0
+        for target_data in training_data:
+            optimizer.zero_grad()
+            prediction = model(graph_data)
+            loss = loss_fn(prediction, target_data)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        if (epoch + 1) % 20 == 0:
+            status_msg = f"Epoch {epoch+1}/100, Loss: {total_loss/len(training_data):.4f}"
+            print(f"   {status_msg}")
+            if training_status_callback:
+                training_status_callback(status_msg)
+    model.eval()
+    print("✅ AI model training complete!")
+    return model
+
+
+# ===== STEP 5: GRADIO INTERFACE & APPLICATION LOGIC =====
+print("\n🎨 Step 5: Creating Gradio user interface")
+
+class StructuralAnalysisApp:
+    def __init__(self, points, graph):
+        self.points = points
+        self.graph = graph
+        self.model = EnhancedSurrogateNet(in_channels=graph.x.shape[1], out_channels=4)
+
+    def train_model_for_ui(self, training_status_update):
+        self.model = train_surrogate_model(self.model, self.graph, training_status_update)
+        return "Model trained successfully! Ready for analysis."
+
+    def analyze(self, young_modulus, load_magnitude):
+        try:
+            E = float(young_modulus) * 1e9
+            load = float(load_magnitude)
+            disp_fem, stress_fem, fixed, loaded = cantilever_beam_fem(self.points, E=E, load_magnitude=load)
+            disp_mag_fem = np.linalg.norm(disp_fem, axis=1)
+            with torch.no_grad():
+                prediction = self.model(self.graph)
+                disp_surrogate = prediction[:, :3].numpy()
+                stress_surrogate = prediction[:, 3].numpy()
+                disp_mag_surrogate = np.linalg.norm(disp_surrogate, axis=1)
+            fig = self.create_3d_plot(disp_mag_fem, stress_fem, fixed, E/1e9, load)
+            results_text = self.format_results_text(
+                disp_mag_fem, stress_fem, disp_mag_surrogate, stress_surrogate, E/1e9, load, fixed
+            )
+            return fig, results_text
+        except Exception as e:
+            error_msg = f"❌ Analysis failed: {str(e)}"
+            print(error_msg)
+            return go.Figure(), error_msg
+
+    def create_3d_plot(self, disp_mag, stress, fixed_nodes, E, load):
         fig = go.Figure()
-        fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Gear Profile', line=dict(width=3)))
-        fig.update_layout(
-            title=f"Gear Profile (Teeth: {teeth}, Module: {module})",
-            xaxis_title="X (mm)",
-            yaxis_title="Y (mm)",
-            showlegend=False,
-            width=600,
-            height=600
-        )
-        fig.update_xaxis(scaleanchor="y", scaleratio=1)
-        
-        specs = f"""
-        **Gear Specifications:**
-        - Number of Teeth: {teeth}
-        - Module: {module}
-        - Pitch Diameter: {teeth * module:.2f} mm
-        - Addendum: {module:.2f} mm
-        - Dedendum: {1.25 * module:.2f} mm
-        """
-        
-        return fig, specs
-    
-    elif component == "Shaft":
-        # Generate shaft 3D visualization
-        theta = np.linspace(0, 2*np.pi, 20)
-        z_vals = np.linspace(0, length, 10)
-        
-        # Create surface plot
-        Z, T = np.meshgrid(z_vals, theta)
-        X = (diameter/2) * np.cos(T)
-        Y = (diameter/2) * np.sin(T)
-        
-        fig = go.Figure(data=[go.Surface(x=X, y=Y, z=Z, colorscale='Blues')])
-        fig.update_layout(
-            title=f"Shaft 3D Model (Length: {length}mm, Diameter: {diameter}mm)",
-            scene=dict(
-                xaxis_title="X (mm)",
-                yaxis_title="Y (mm)",
-                zaxis_title="Z (mm)"
+        fig.add_trace(go.Scatter3d(
+            x=self.points[:, 0], y=self.points[:, 1], z=self.points[:, 2],
+            mode='markers',
+            marker=dict(
+                size=4, color=disp_mag, colorscale='Viridis',
+                colorbar=dict(title="Displacement (m)"),
+                cmin=disp_mag.min(), cmax=disp_mag.max()
             ),
-            width=600,
-            height=500
+            text=[f"Stress: {s/1e6:.2f} MPa" for s in stress],
+            hoverinfo='text', name='Deformation Field'
+        ))
+        fig.add_trace(go.Scatter3d(
+            x=self.points[fixed_nodes, 0], y=self.points[fixed_nodes, 1], z=self.points[fixed_nodes, 2],
+            mode='markers', marker=dict(size=6, color='red', symbol='x'), name='Fixed Support'
+        ))
+        fig.update_layout(
+            title=f"Analysis Results (E={E:.0f} GPa, Load={load:.0f} N)",
+            scene=dict(xaxis_title="X (m)", yaxis_title="Y (m)", zaxis_title="Z (m)"),
+            width=800, height=600, margin=dict(l=0, r=0, b=0, t=40)
         )
-        
-        specs = f"""
-        **Shaft Specifications:**
-        - Length: {length} mm
-        - Diameter: {diameter} mm
-        - Cross-sectional Area: {np.pi * (diameter/2)**2:.2f} mm²
-        - Moment of Inertia: {np.pi * diameter**4 / 64:.2f} mm⁴
+        return fig
+
+    def format_results_text(self, disp_fem, stress_fem, disp_surrogate, stress_surrogate, E, load, fixed):
+        corr_disp = np.corrcoef(disp_fem, disp_surrogate)[0, 1]
+        corr_stress = np.corrcoef(stress_fem, stress_surrogate)[0, 1]
+        return f"""
+        ### 📊 Analysis Summary
+        | Parameter | Value |
+        | :--- | :--- |
+        | **Young's Modulus** | {E:.0f} GPa |
+        | **Load Magnitude** | {load:.0f} N |
+        | **Mesh Nodes** | {len(self.points):,} |
+        | **Fixed Nodes** | {len(fixed):,} |
+
+        ### 🤖 AI vs. FEM Comparison
+        | Metric | FEM (Ground Truth) | AI Surrogate | Correlation |
+        | :--- | :--- | :--- | :--- |
+        | **Max Displacement** | `{disp_fem.max():.3e} m` | `{disp_surrogate.max():.3e} m` | **`{corr_disp:.3f}`** |
+        | **Max Stress** | `{stress_fem.max()/1e6:.3f} MPa` | `{stress_surrogate.max()/1e6:.3f} MPa` | **`{corr_stress:.3f}`** |
         """
-        
-        return fig, specs
-    
-    return go.Figure(), "Select a component type"
-
-# FEA Analysis
-def perform_fea_analysis(material, force, area, length=1000):
-    # Get material properties
-    mat_data = materials_db[materials_db['Material'] == material].iloc[0]
-    
-    E = mat_data['Elastic Modulus (GPa)'] * 1e9  # Pa
-    yield_strength = mat_data['Yield Strength (MPa)'] * 1e6  # Pa
-    
-    # Calculate stress and displacement
-    stress = force / (area / 1e6)  # Convert area from mm² to m²
-    displacement = stress / E * length  # mm
-    safety_factor = yield_strength / stress if stress > 0 else 10
-    
-    # Generate stress distribution
-    n_points = 50
-    x_pos = np.linspace(0, length, n_points)
-    stress_dist = stress * (1 + 0.3 * np.sin(2 * np.pi * x_pos / length)) / 1e6  # MPa
-    
-    # Create plot
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=x_pos, 
-        y=stress_dist,
-        mode='lines+markers',
-        name='Stress Distribution',
-        line=dict(width=3, color='red')
-    ))
-    fig.update_layout(
-        title="Stress Distribution Along Component",
-        xaxis_title="Position (mm)",
-        yaxis_title="Stress (MPa)",
-        width=600,
-        height=400
-    )
-    
-    # Add safety limit line
-    fig.add_hline(y=mat_data['Yield Strength (MPa)'], 
-                  line_dash="dash", line_color="orange",
-                  annotation_text="Yield Strength Limit")
-    
-    # Results summary
-    results = f"""
-    **FEA Analysis Results:**
-    - Material: {material}
-    - Max Stress: {stress/1e6:.2f} MPa
-    - Max Displacement: {displacement:.4f} mm
-    - Safety Factor: {safety_factor:.2f}
-    - Status: {'✅ SAFE' if safety_factor > 2 else '⚠️ CHECK DESIGN'}
-    
-    **Material Properties:**
-    - Yield Strength: {mat_data['Yield Strength (MPa)']} MPa
-    - Elastic Modulus: {mat_data['Elastic Modulus (GPa)']} GPa
-    - Density: {mat_data['Density (kg/m³)']} kg/m³
-    """
-    
-    return fig, results
-
-# Material Selection
-def material_selector(min_strength, max_cost, min_temp):
-    # Filter materials based on criteria
-    filtered = materials_db[
-        (materials_db['Yield Strength (MPa)'] >= min_strength) &
-        (materials_db['Cost ($/kg)'] <= max_cost) &
-        (materials_db['Temperature Limit (°C)'] >= min_temp)
-    ]
-    
-    if filtered.empty:
-        return "No materials match your criteria. Please adjust requirements.", go.Figure()
-    
-    # Create comparison chart
-    fig = px.scatter(filtered, 
-                    x='Yield Strength (MPa)', 
-                    y='Cost ($/kg)',
-                    size='Density (kg/m³)',
-                    color='Material',
-                    hover_data=['Temperature Limit (°C)'],
-                    title='Recommended Materials')
-    fig.update_layout(width=600, height=400)
-    
-    # Format results table
-    result_table = filtered[['Material', 'Yield Strength (MPa)', 'Cost ($/kg)', 'Temperature Limit (°C)']].to_string(index=False)
-    
-    return f"**Recommended Materials:**\n```\n{result_table}\n```", fig
-
-# Gear Calculator
-def gear_calculator(teeth, module, power, speed):
-    # Basic calculations
-    pitch_diameter = teeth * module
-    torque = (power * 1000 * 60) / (2 * np.pi * speed)  # N⋅mm
-    pitch_line_velocity = (np.pi * pitch_diameter * speed) / (60 * 1000)  # m/s
-    
-    # Lewis equation for bending stress (simplified)
-    lewis_factor = 0.154 - 0.912/teeth  # Approximation
-    face_width = 10 * module  # Typical assumption
-    tangential_force = 2 * torque / pitch_diameter
-    bending_stress = tangential_force / (face_width * module * lewis_factor)
-    
-    # Material recommendation
-    required_strength = bending_stress * 3  # Safety factor of 3
-    suitable_materials = materials_db[materials_db['Yield Strength (MPa)'] >= required_strength/1e6]
-    
-    if not suitable_materials.empty:
-        recommended = suitable_materials.iloc[0]['Material']
-    else:
-        recommended = "High-strength steel required"
-    
-    results = f"""
-    **Gear Design Results:**
-    - Pitch Diameter: {pitch_diameter:.2f} mm
-    - Torque: {torque:.2f} N⋅mm
-    - Pitch Line Velocity: {pitch_line_velocity:.2f} m/s
-    - Estimated Face Width: {face_width:.2f} mm
-    - Bending Stress: {bending_stress/1e6:.2f} MPa
-    - Recommended Material: {recommended}
-    
-    **Design Notes:**
-    - Use appropriate lubrication for velocities > 5 m/s
-    - Consider heat treatment for high-stress applications
-    - Verify contact stress separately
-    """
-    
-    return results
-
-# Create Gradio Interface
-def create_interface():
-    with gr.Blocks(title="MechMind - AI Mechanical Engineering Assistant", theme=gr.themes.Soft()) as app:
-        
-        gr.Markdown("""
-        # 🔧 MechMind - AI Mechanical Engineering Assistant
-        ### AI-powered platform for mechanical design, analysis, and optimization
-        **Features:** 3D Model Generation | Advanced FEA | Smart Material Selection | AI Engineering Assistant
-        """)
-        
-        with gr.Tabs():
-            # Dashboard Tab
-            with gr.TabItem("🏠 Dashboard"):
-                gr.Markdown("## Engineering Dashboard")
-                
-                with gr.Row():
-                    gr.Markdown(f"**Materials Database:** {len(materials_db)} materials")
-                    gr.Markdown("**AI Models Active:** 5")
-                    gr.Markdown("**Success Rate:** 96.8%")
-                
-                gr.Markdown("### 📊 Materials Overview")
-                materials_plot = px.scatter(materials_db, 
-                                          x='Yield Strength (MPa)', 
-                                          y='Cost ($/kg)',
-                                          size='Density (kg/m³)',
-                                          color='Material',
-                                          title='Material Properties Comparison')
-                gr.Plot(materials_plot)
-            
-            # 3D Design Generator Tab
-            with gr.TabItem("🔧 3D Design Generator"):
-                gr.Markdown("## AI-Powered 3D Model Generator")
-                
-                with gr.Row():
-                    with gr.Column():
-                        component_type = gr.Dropdown(["Gear", "Shaft"], label="Component Type", value="Gear")
-                        
-                        # Gear parameters
-                        teeth_input = gr.Slider(8, 100, value=20, step=1, label="Number of Teeth")
-                        module_input = gr.Slider(0.5, 10, value=2, step=0.5, label="Module")
-                        
-                        # Shaft parameters  
-                        length_input = gr.Slider(50, 500, value=100, step=10, label="Length (mm)")
-                        diameter_input = gr.Slider(10, 100, value=20, step=5, label="Diameter (mm)")
-                        
-                        generate_btn = gr.Button("Generate 3D Model", variant="primary")
-                    
-                    with gr.Column():
-                        model_plot = gr.Plot(label="3D Model")
-                        model_specs = gr.Markdown(label="Specifications")
-                
-                generate_btn.click(
-                    generate_3d_model,
-                    inputs=[component_type, teeth_input, module_input, length_input, diameter_input],
-                    outputs=[model_plot, model_specs]
-                )
-            
-            # Material Selector Tab
-            with gr.TabItem("📊 Material Selector"):
-                gr.Markdown("## Smart Material Selection")
-                
-                with gr.Row():
-                    with gr.Column():
-                        min_strength = gr.Slider(0, 1000, value=200, label="Min Yield Strength (MPa)")
-                        max_cost = gr.Slider(0, 50, value=10, label="Max Cost ($/kg)")
-                        min_temp = gr.Slider(0, 1000, value=200, label="Min Temperature Limit (°C)")
-                        
-                        select_btn = gr.Button("Find Materials", variant="primary")
-                    
-                    with gr.Column():
-                        selection_results = gr.Markdown(label="Recommended Materials")
-                        selection_plot = gr.Plot(label="Material Comparison")
-                
-                select_btn.click(
-                    material_selector,
-                    inputs=[min_strength, max_cost, min_temp],
-                    outputs=[selection_results, selection_plot]
-                )
-            
-            # FEA Analyzer Tab
-            with gr.TabItem("🔍 FEA Analyzer"):
-                gr.Markdown("## Finite Element Analysis")
-                
-                with gr.Row():
-                    with gr.Column():
-                        fea_material = gr.Dropdown(materials_db['Material'].tolist(), 
-                                                 label="Material", value="Steel 1045")
-                        fea_force = gr.Number(value=1000, label="Applied Force (N)")
-                        fea_area = gr.Number(value=100, label="Cross-sectional Area (mm²)")
-                        fea_length = gr.Number(value=1000, label="Component Length (mm)")
-                        
-                        fea_btn = gr.Button("Run FEA Analysis", variant="primary")
-                    
-                    with gr.Column():
-                        fea_plot = gr.Plot(label="Stress Distribution")
-                        fea_results = gr.Markdown(label="Analysis Results")
-                
-                fea_btn.click(
-                    perform_fea_analysis,
-                    inputs=[fea_material, fea_force, fea_area, fea_length],
-                    outputs=[fea_plot, fea_results]
-                )
-            
-            # Gear Calculator Tab
-            with gr.TabItem("⚙️ Gear Calculator"):
-                gr.Markdown("## Gear Design Calculator")
-                
-                with gr.Row():
-                    with gr.Column():
-                        gear_teeth = gr.Number(value=20, label="Number of Teeth")
-                        gear_module = gr.Number(value=2, label="Module")
-                        gear_power = gr.Number(value=10, label="Power (kW)")
-                        gear_speed = gr.Number(value=1000, label="Speed (rpm)")
-                        
-                        calc_btn = gr.Button("Calculate Gear Parameters", variant="primary")
-                    
-                    with gr.Column():
-                        gear_results = gr.Markdown(label="Gear Design Results")
-                
-                calc_btn.click(
-                    gear_calculator,
-                    inputs=[gear_teeth, gear_module, gear_power, gear_speed],
-                    outputs=[gear_results]
-                )
-            
-            # AI Assistant Tab
-            with gr.TabItem("💬 AI Assistant"):
-                gr.Markdown("## RAG AI Engineering Assistant")
-                
-                with gr.Row():
-                    with gr.Column():
-                        user_query = gr.Textbox(label="Ask your engineering question:", 
-                                              placeholder="e.g., How do I select materials for high-temperature applications?")
-                        ask_btn = gr.Button("Ask AI", variant="primary")
-                        
-                        gr.Markdown("### Quick Questions:")
-                        with gr.Row():
-                            material_btn = gr.Button("Material Selection")
-                            design_btn = gr.Button("Design Tips")
-                            stress_btn = gr.Button("Stress Analysis")
-                    
-                    with gr.Column():
-                        ai_response = gr.Markdown(label="AI Response")
-                
-                ask_btn.click(get_ai_response, inputs=[user_query], outputs=[ai_response])
-                material_btn.click(lambda: get_ai_response("material selection"), outputs=[ai_response])
-                design_btn.click(lambda: get_ai_response("design optimization"), outputs=[ai_response])
-                stress_btn.click(lambda: get_ai_response("stress analysis"), outputs=[ai_response])
-        
-        gr.Markdown("""
-        ---
-        ### 🔧 MechMind AI Assistant - Empowering Mechanical Engineers with AI
-        **Built with Gradio | Ready for Kaggle Deployment**
-        """)
-    
-    return app
-
-# Launch the application
-if __name__ == "__main__":
-    app = create_interface()
-    
-    # Kaggle-specific launch configuration
-    import os
-    
-    # Check if running in Kaggle environment
-    if 'KAGGLE_KERNEL_RUN_TYPE' in os.environ:
-        print("🔧 Detected Kaggle environment - launching locally")
-        print("📍 Access the app at: http://localhost:7860")
-        print("💡 If running in Kaggle, the app will be available in the output cell")
-        app.launch(
-            share=False,          # Disable share link in Kaggle
-            debug=False,          # Disable debug mode
-            server_name="0.0.0.0", # Allow external access
-            server_port=7860,     # Standard port
-            inbrowser=False,      # Don't try to open browser
-            show_error=True,      # Show errors in interface
-            quiet=False           # Show startup messages
-        )
-    else:
-        # Try to launch with share for local development
-        try:
-            print("🚀 Launching MechMind with public share link...")
-            app.launch(share=True, debug=False, server_name="0.0.0.0", server_port=7860)
-        except Exception as e:
-            print(f"❌ Share link creation failed: {e}")
-            print("🔧 Launching locally instead...")
-            app.launch(
-                share=False, 
-                debug=False, 
-                server_name="0.0.0.0", 
-                server_port=7860, 
-                inbrowser=True
-            )
+
+app = StructuralAnalysisApp(points, graph)
+
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Structural Analysis") as demo:
+    gr.Markdown("# 🏗️ AI-Powered Structural Analysis")
+    gr.Markdown("An interactive tool combining Finite Element Method (FEM) with a Graph Neural Network (GNN) surrogate model. The GNN is trained in real-time on FEM data to provide fast, accurate predictions.")
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🛠️ Parameters")
+            young_modulus = gr.Slider(minimum=50, maximum=300, value=210, step=10, label="Young's Modulus (GPa)")
+            load_magnitude = gr.Slider(minimum=-5000, maximum=-100, value=-1000, step=100, label="Load Magnitude (N)")
+            with gr.Accordion("Advanced: AI Model Training", open=False):
+                training_status = gr.Textbox(label="Training Status", value="Model is not trained yet.", interactive=False)
+                train_btn = gr.Button("🧠 Train AI Model")
+            analyze_btn = gr.Button("🚀 Run Analysis", variant="primary")
+        with gr.Column(scale=2):
+            gr.Markdown("### 📈 Visualization & Results")
+            plot_output = gr.Plot(label="3D Visualization")
+            results_text = gr.Markdown()
+    train_btn.click(fn=app.train_model_for_ui, inputs=[], outputs=[training_status], show_progress='full')
+    analyze_btn.click(fn=app.analyze, inputs=[young_modulus, load_magnitude], outputs=[plot_output, results_text])
+    demo.load(fn=app.train_model_for_ui, inputs=[], outputs=[training_status], show_progress='full')
+
+print("🌐 Launching Gradio interface...")
+demo.launch(share=True, debug=True)