Update src/streamlit_app.py

src/streamlit_app.py

@@ -31,35 +31,15 @@ try:
 except ImportError:
     TENSORFLOW_AVAILABLE = False
 
-# ULTRA-AGGRESSIVE CSS FIX - Complete stability
+# Custom CSS for better styling
 st.markdown("""
 <style>
-    /* FORCE HEADER TO BE COMPLETELY FIXED AND STABLE */
     .main-header {
-        font-size: 2.5rem !important;
-        color: #1e88e5 !important;
-        text-align: center !important;
-        margin-bottom: 2rem !important;
-        position: fixed !important;
-        top: 0 !important;
-        left: 0 !important;
-        right: 0 !important;
-        width: 100% !important;
-        background: white !important;
-        z-index: 99999 !important;
-        padding: 1rem 0 !important;
-        border-bottom: 3px solid #1e88e5 !important;
-        box-shadow: 0 4px 8px rgba(0,0,0,0.15) !important;
-        transform: translateZ(0) !important;
-        will-change: auto !important;
+        font-size: 2.5rem;
+        color: #1e88e5;
+        text-align: center;
+        margin-bottom: 2rem;
     }
-    
-    /* ADD TOP MARGIN TO MAIN CONTENT TO AVOID OVERLAP */
-    .main > .block-container {
-        margin-top: 120px !important;
-        padding-top: 20px !important;
-    }
-    
     .section-header {
         font-size: 1.5rem;
         color: #424242;
@@ -84,57 +64,6 @@ st.markdown("""
         padding: 1rem;
         margin: 1rem 0;
     }
-    
-    /* NUCLEAR OPTION: DISABLE ALL ANIMATIONS AND TRANSITIONS EVERYWHERE */
-    *, *::before, *::after {
-        transition: none !important;
-        animation: none !important;
-        animation-duration: 0s !important;
-        animation-delay: 0s !important;
-        transform: none !important;
-    }
-    
-    /* FORCE STABILITY ON ALL STREAMLIT ELEMENTS */
-    .stProgress, .stProgress > div, .stProgress * {
-        transition: none !important;
-        animation: none !important;
-        transform: none !important;
-    }
-    
-    .stSpinner, .stSpinner > div, .stSpinner * {
-        transition: none !important;
-        animation: none !important;
-        transform: none !important;
-        position: relative !important;
-    }
-    
-    /* STABILIZE CONTAINERS */
-    .element-container, .stMarkdown, .stButton {
-        transition: none !important;
-        animation: none !important;
-        transform: none !important;
-    }
-    
-    /* PREVENT LAYOUT SHIFTS */
-    .main .block-container .element-container {
-        transition: none !important;
-        animation: none !important;
-    }
-    
-    /* FORCE GPU ACCELERATION FOR STABILITY */
-    .main-header {
-        transform: translate3d(0,0,0) !important;
-        backface-visibility: hidden !important;
-        perspective: 1000px !important;
-    }
-    
-    /* HIDE STREAMLIT'S RERUN INDICATOR */
-    .stAppViewMain > .main > .block-container > div:first-child {
-        visibility: hidden !important;
-        height: 0 !important;
-        margin: 0 !important;
-        padding: 0 !important;
-    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -147,10 +76,15 @@ if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 
 
-# ULTRA-OPTIMIZED BubbleSimulation class - ZERO UI UPDATES during simulation
+# Complete OptimizedBubbleSimulation class - matches GUI implementation exactly
 class OptimizedBubbleSimulation:
     """
-    ULTRA-OPTIMIZED version - ZERO UI updates during simulation to prevent any trembling
+    OPTIMIZED version of BubbleSimulation class - matches GUI implementation
+    Key optimizations while preserving physics:
+    1. Reduced mesh resolution (NT = 100 instead of 500)
+    2. Shorter simulation time for validation
+    3. Optimized ODE solver settings
+    4. Simplified some less critical calculations
     """
 
     def __init__(self):
@@ -184,8 +118,10 @@ class OptimizedBubbleSimulation:
         self.NT = 100  # Reduced from 500 to 100 (5x faster, still accurate)
         self.RelTol = 1e-5  # Relaxed from 1e-7 to 1e-5 (faster convergence)
 
+        # Note: lambdamax will be set dynamically from .mat file in run_optimized_simulation
+
     def run_optimized_simulation(self, G, mu, lambda_max_mean=None):
-        """ULTRA-OPTIMIZED simulation - ZERO UI updates to prevent trembling"""
+        """Run optimized simulation - much faster while preserving core physics"""
         from scipy.integrate import solve_ivp
 
         # Set lambdamax from loaded data or use default
@@ -196,7 +132,7 @@ class OptimizedBubbleSimulation:
             self.lambdamax = 5.99  # Fallback default
             print(f"Warning: Using default lambda_max = {self.lambdamax}")
 
-        print(f"Running ULTRA-OPTIMIZED simulation with predicted G={G:.2e} Pa, μ={mu:.4f} Pa·s")
+        print(f"Running OPTIMIZED simulation with predicted G={G:.2e} Pa, μ={mu:.4f} Pa·s")
 
         # Use predicted values
         self.G = G
@@ -214,7 +150,9 @@ class OptimizedBubbleSimulation:
             self.Rc = self.Rmax
             self.Uc = np.sqrt(self.P_inf / self.rho)
             self.tc = self.Rmax / self.Uc
-            self.tspan = 3 * self.tc  # Reduced for speed
+
+            # OPTIMIZATION: Shorter simulation time for validation (3x instead of 6x)
+        self.tspan = 3 * self.tc  # Reduced from 6*tc to 3*tc (2x faster)
 
         # Calculate parameters (same as original)
         self.Pv = self.P_ref * np.exp(-self.T_ref / self.T_inf)
@@ -260,51 +198,54 @@ class OptimizedBubbleSimulation:
 
         X0 = np.concatenate([[R0_star, U0_star, P0_star, S0], Theta0, k0])
 
-        print(f"State vector size: {len(X0)} (4 + {self.NT} + {self.NT})")
-        print(f"Time span: 0 to {self.tspan_star:.4f}")
+        print(f"Optimized state vector size: {len(X0)} (4 + {self.NT} + {self.NT})")
+        print(f"Time span: 0 to {self.tspan_star:.4f} (reduced for speed)")
 
-        # CRITICAL FIX: NO UI UPDATES AT ALL - store them for later
-        self.simulation_status = "Starting simulation..."
+        # Add progress tracking for Streamlit
+        progress_bar = st.progress(0, text="Starting simulation...")
 
-        # ULTRA-OPTIMIZED ODE solving - NO UI updates during solving
+        # OPTIMIZED ODE solving with relaxed tolerances and larger time steps
         try:
             sol = solve_ivp(
-                self.bubble_optimized,
+                self.bubble_optimized,  # Optimized bubble physics
                 [0, self.tspan_star],
                 X0,
                 method='BDF',
-                rtol=self.RelTol,
-                atol=1e-8,
-                max_step=self.tspan_star / 200,
-                dense_output=False
+                rtol=self.RelTol,  # Relaxed tolerance for speed
+                atol=1e-8,  # Relaxed tolerance
+                max_step=self.tspan_star / 200,  # Larger steps (was 500, now 200) for speed
+                dense_output=False  # Disable dense output for speed
             )
 
-            self.simulation_status = "Processing results..."
+            progress_bar.progress(0.8, text="Processing results...")
 
         except Exception as e:
             print(f"BDF failed: {str(e)}, trying LSODA...")
-            self.simulation_status = "Trying backup solver..."
+            progress_bar.progress(0.5, text="Trying backup solver...")
             try:
                 sol = solve_ivp(
                     self.bubble_optimized,
                     [0, self.tspan_star],
                     X0,
                     method='LSODA',
-                    rtol=1e-4,
+                    rtol=1e-4,  # Further relaxed for speed
                     atol=1e-7,
-                    max_step=self.tspan_star / 100,
+                    max_step=self.tspan_star / 100,  # Even larger steps for speed
                 )
             except Exception as e2:
                 print(f"All solvers failed: {str(e2)}")
+                progress_bar.empty()
                 return self.fast_fallback()
 
         if not sol.success:
             print(f"Solver failed: {sol.message}")
+            progress_bar.empty()
             return self.fast_fallback()
 
         # Extract solution
         t_nondim = sol.t
         X_nondim = sol.y.T
+
         R_nondim = X_nondim[:, 0]
 
         # Filter valid solutions
@@ -314,6 +255,7 @@ class OptimizedBubbleSimulation:
 
         if len(t_nondim) < 10:
             print("Too few valid points, using fast fallback")
+            progress_bar.empty()
             return self.fast_fallback()
 
         # Back to physical units
@@ -325,9 +267,11 @@ class OptimizedBubbleSimulation:
         t_newunit = t * scale
         R_newunit = R * scale
 
-        self.simulation_status = "Simulation complete!"
+        progress_bar.progress(1.0, text="Simulation complete!")
+        time.sleep(0.5)
+        progress_bar.empty()
 
-        print(f"ULTRA-OPTIMIZED simulation completed in {len(t_newunit)} points!")
+        print(f"Optimized simulation completed in {len(t_newunit)} points!")
         print(f"Time range: {t_newunit[0]:.3f} to {t_newunit[-1]:.3f} (0.1 ms)")
         print(f"Radius range: {np.min(R_newunit):.3f} to {np.max(R_newunit):.3f} (0.1 mm)")
 
@@ -335,7 +279,8 @@ class OptimizedBubbleSimulation:
 
     def bubble_optimized(self, t, x):
         """
-        OPTIMIZED bubble physics function - same physics, no UI updates
+        OPTIMIZED version of bubble physics function - COMPLETE IMPLEMENTATION matching GUI
+        Same physics but with computational optimizations
         """
         # Extract parameters (same as original)
         NT = int(self.params[0])
@@ -521,7 +466,7 @@ class OptimizedBubbleSimulation:
 
 # Main Streamlit App
 def main():
-    # Header - ULTRA-STABLE with fixed positioning
+    # Header
     st.markdown('<h1 class="main-header">🫧 Bubble Dynamics Transformer</h1>', unsafe_allow_html=True)
 
     # Initialize current page in session state
@@ -1397,7 +1342,7 @@ Ready for validation simulation!"""
 
 
 def show_validation():
-    """ULTRA-STABLE Validation interface - NO TREMBLING GUARANTEED"""
+    """Validation interface - exactly matches desktop GUI"""
     st.markdown('<h2 class="section-header">✅ Validation</h2>', unsafe_allow_html=True)
 
     if not st.session_state.processed_data:
@@ -1432,98 +1377,83 @@ def show_validation():
         if 'lambda_max_mean' in st.session_state:
             st.write(f"**λ_max:** {st.session_state.lambda_max_mean:.3f}")
 
-    # ULTRA-CRITICAL FIX: Separate containers to completely isolate dynamic content
-    button_placeholder = st.empty()
-    results_placeholder = st.empty()
-
-    # Put the button in its own isolated container
-    with button_placeholder.container():
-        run_simulation = st.button("🚀 Run Validation Simulation", type="primary", key="validation_button")
-
-    if run_simulation:
+    if st.button("🚀 Run Validation Simulation", type="primary"):
         # Check required data (exactly like desktop GUI)
         if st.session_state.lambda_max_mean is None:
             st.error("No lambda_max_mean loaded. Please load data first.")
-        else:
-            # CRITICAL: Use the isolated results container for ALL dynamic content
-            with results_placeholder.container():
-                # Create a status message (NOT spinner to avoid animations)
-                status_text = st.empty()
-                status_text.text("🔄 Running ultra-optimized bubble simulation...")
-                
-                try:
-                    # Extract values exactly like desktop GUI
-                    G_value = st.session_state.pred_G[0][0] if st.session_state.pred_G.ndim > 1 else \
-                    st.session_state.pred_G[0]
-                    mu_value = st.session_state.pred_mu[0][0] if st.session_state.pred_mu.ndim > 1 else \
-                    st.session_state.pred_mu[0]
+            return
 
-                    # Initialize simulation
-                    bubble_sim = OptimizedBubbleSimulation()
+        with st.spinner("Running optimized bubble simulation..."):
+            try:
+                # Extract values exactly like desktop GUI
+                G_value = st.session_state.pred_G[0][0] if st.session_state.pred_G.ndim > 1 else \
+                st.session_state.pred_G[0]
+                mu_value = st.session_state.pred_mu[0][0] if st.session_state.pred_mu.ndim > 1 else \
+                st.session_state.pred_mu[0]
+
+                # Initialize simulation
+                bubble_sim = OptimizedBubbleSimulation()
+
+                # Run simulation (exactly like desktop GUI)
+                start_time = time.time()
+                t_sim, R_sim = bubble_sim.run_optimized_simulation(G_value, mu_value, st.session_state.lambda_max_mean)
+                simulation_time = time.time() - start_time
+
+                # Store simulation results
+                st.session_state.t_sim = t_sim
+                st.session_state.R_sim = R_sim
+
+                # Create comparison plot (exactly like desktop GUI)
+                fig, ax = plt.subplots(figsize=(10, 6))
+
+                ax.plot(st.session_state.t_interp_newunit, st.session_state.R_interp_newunit,
+                        'ro', markersize=4, label='Interpolated (Experimental)', alpha=0.7)
+                ax.plot(t_sim, R_sim, 'b-', linewidth=2, label='Simulated (Predicted G & μ)')
+
+                ax.set_xlabel('Time (0.1 ms)')
+                ax.set_ylabel('Radius (0.1 mm)')
+                ax.set_title('Validation: Experimental vs Simulated R-t Curves (Optimized)')
+                ax.grid(True, alpha=0.3)
+                ax.legend()
+
+                # Calculate error metrics (exactly like desktop GUI)
+                if len(t_sim) > 0 and len(st.session_state.t_interp_newunit) > 0:
+                    t_min = max(st.session_state.t_interp_newunit[0], t_sim[0])
+                    t_max = min(st.session_state.t_interp_newunit[-1], t_sim[-1])
+
+                    if t_max > t_min:
+                        f_sim = interp1d(t_sim, R_sim, kind='linear', bounds_error=False, fill_value='extrapolate')
+
+                        mask = (st.session_state.t_interp_newunit >= t_min) & (
+                                    st.session_state.t_interp_newunit <= t_max)
+                        t_common = st.session_state.t_interp_newunit[mask]
+                        R_exp_common = st.session_state.R_interp_newunit[mask]
+                        R_sim_common = f_sim(t_common)
+
+                        if len(R_exp_common) > 0:
+                            rmse = np.sqrt(np.mean((R_exp_common - R_sim_common) ** 2))
+                            mae = np.mean(np.abs(R_exp_common - R_sim_common))
+                            max_error = np.max(np.abs(R_exp_common - R_sim_common))
+
+                            error_text = f'RMSE: {rmse:.3f}\nMAE: {mae:.3f}\nMax Error: {max_error:.3f}'
+                            ax.text(0.02, 0.98, error_text, transform=ax.transAxes,
+                                    verticalalignment='top', bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+
+                plt.tight_layout()
+                st.pyplot(fig)
+
+                # Display validation metrics
+                if 'rmse' in locals():
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.metric("RMSE", f"{rmse:.3f}")
+                    with col2:
+                        st.metric("MAE", f"{mae:.3f}")
+                    with col3:
+                        st.metric("Max Error", f"{max_error:.3f}")
 
-                    # Run simulation (NO UI UPDATES inside simulation)
-                    start_time = time.time()
-                    t_sim, R_sim = bubble_sim.run_optimized_simulation(G_value, mu_value, st.session_state.lambda_max_mean)
-                    simulation_time = time.time() - start_time
-
-                    # Clear status and show results
-                    status_text.empty()
-
-                    # Store simulation results
-                    st.session_state.t_sim = t_sim
-                    st.session_state.R_sim = R_sim
-
-                    # Create comparison plot (exactly like desktop GUI)
-                    fig, ax = plt.subplots(figsize=(10, 6))
-
-                    ax.plot(st.session_state.t_interp_newunit, st.session_state.R_interp_newunit,
-                            'ro', markersize=4, label='Interpolated (Experimental)', alpha=0.7)
-                    ax.plot(t_sim, R_sim, 'b-', linewidth=2, label='Simulated (Predicted G & μ)')
-
-                    ax.set_xlabel('Time (0.1 ms)')
-                    ax.set_ylabel('Radius (0.1 mm)')
-                    ax.set_title('Validation: Experimental vs Simulated R-t Curves (Ultra-Optimized)')
-                    ax.grid(True, alpha=0.3)
-                    ax.legend()
-
-                    # Calculate error metrics (exactly like desktop GUI)
-                    if len(t_sim) > 0 and len(st.session_state.t_interp_newunit) > 0:
-                        t_min = max(st.session_state.t_interp_newunit[0], t_sim[0])
-                        t_max = min(st.session_state.t_interp_newunit[-1], t_sim[-1])
-
-                        if t_max > t_min:
-                            f_sim = interp1d(t_sim, R_sim, kind='linear', bounds_error=False, fill_value='extrapolate')
-
-                            mask = (st.session_state.t_interp_newunit >= t_min) & (
-                                        st.session_state.t_interp_newunit <= t_max)
-                            t_common = st.session_state.t_interp_newunit[mask]
-                            R_exp_common = st.session_state.R_interp_newunit[mask]
-                            R_sim_common = f_sim(t_common)
-
-                            if len(R_exp_common) > 0:
-                                rmse = np.sqrt(np.mean((R_exp_common - R_sim_common) ** 2))
-                                mae = np.mean(np.abs(R_exp_common - R_sim_common))
-                                max_error = np.max(np.abs(R_exp_common - R_sim_common))
-
-                                error_text = f'RMSE: {rmse:.3f}\nMAE: {mae:.3f}\nMax Error: {max_error:.3f}'
-                                ax.text(0.02, 0.98, error_text, transform=ax.transAxes,
-                                        verticalalignment='top', bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
-
-                    plt.tight_layout()
-                    st.pyplot(fig)
-
-                    # Display validation metrics
-                    if 'rmse' in locals():
-                        col1, col2, col3 = st.columns(3)
-                        with col1:
-                            st.metric("RMSE", f"{rmse:.3f}")
-                        with col2:
-                            st.metric("MAE", f"{mae:.3f}")
-                        with col3:
-                            st.metric("Max Error", f"{max_error:.3f}")
-
-                    # Show detailed results (matching desktop GUI message)
-                    validation_results = f"""**Validation Results (Ultra-Optimized):**
+                # Show detailed results (matching desktop GUI message)
+                validation_results = f"""**Validation Results (Optimized):**
 
 **Predicted Values:**
 - Shear Modulus (G): {G_value:.2e} Pa
@@ -1531,26 +1461,25 @@ def show_validation():
 - Lambda Max: {st.session_state.lambda_max_mean:.3f} (from .mat file)
 
 **Simulation Performance:**
-- Simulation Time: {simulation_time:.2f} seconds (ultra-fast!)
+- Simulation Time: {simulation_time:.2f} seconds (much faster!)
 - Simulated Points: {len(R_sim)}
 - Time Range: {t_sim[0]:.3f} to {t_sim[-1]:.3f} (0.1 ms)
 
 The plot shows comparison between experimental (dots) and 
 simulated (line) R-t curves using predicted material properties.
-Note: This uses ultra-optimized simulation with ZERO UI updates during execution."""
+Note: This uses an optimized simulation for faster results."""
 
-                    st.success("✅ Validation simulation completed!")
-                    st.info(validation_results)
+                st.success("✅ Validation simulation completed!")
+                st.info(validation_results)
 
-                except Exception as e:
-                    status_text.empty()
-                    st.error(f"Simulation failed: {str(e)}")
+            except Exception as e:
+                st.error(f"Simulation failed: {str(e)}")
 
-                    with st.expander("🔍 Debug Information"):
-                        st.write(f"**Error:** {str(e)}")
-                        st.write(f"**G value:** {G_value if 'G_value' in locals() else 'N/A'}")
-                        st.write(f"**μ value:** {mu_value if 'mu_value' in locals() else 'N/A'}")
-                        st.write(f"**Lambda:** {st.session_state.get('lambda_max_mean', 'N/A')}")
+                with st.expander("🔍 Debug Information"):
+                    st.write(f"**Error:** {str(e)}")
+                    st.write(f"**G value:** {G_value if 'G_value' in locals() else 'N/A'}")
+                    st.write(f"**μ value:** {mu_value if 'mu_value' in locals() else 'N/A'}")
+                    st.write(f"**Lambda:** {st.session_state.get('lambda_max_mean', 'N/A')}")
 
 
 def show_results():