Update src/streamlit_app.py

src/streamlit_app.py

@@ -31,35 +31,22 @@ try:
 except ImportError:
     TENSORFLOW_AVAILABLE = False
 
-# STABLE CSS with responsive feedback - No trembling but shows progress
+# FIXED CSS for stable header and no trembling
 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;
+        font-size: 2.5rem;
+        color: #1e88e5;
+        text-align: center;
+        margin-bottom: 2rem;
+        position: sticky !important;
         top: 0 !important;
-        left: 0 !important;
-        right: 0 !important;
-        width: 100% !important;
         background: white !important;
-        z-index: 99999 !important;
+        z-index: 9999 !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;
+        border-bottom: 2px solid #1e88e5 !important;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1) !important;
     }
-    
-    /* 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,41 +71,24 @@ st.markdown("""
         padding: 1rem;
         margin: 1rem 0;
     }
-    
-    /* DISABLE PROBLEMATIC ANIMATIONS - Allow safe text updates */
-    .stProgress, .stProgress > div, .stProgress * {
+    /* Prevent all animation/transition effects that cause trembling */
+    * {
         transition: none !important;
         animation: none !important;
-        transform: none !important;
     }
-    
-    .stSpinner, .stSpinner > div, .stSpinner * {
+    /* Stabilize progress elements */
+    .stProgress > div {
         transition: none !important;
-        animation: none !important;
-        transform: none !important;
-        position: relative !important;
     }
-    
-    /* STABILIZE CONTAINERS - Allow content updates but prevent header shifts */
-    .element-container, .stButton {
+    .stSpinner > div {
         transition: none !important;
-        animation: none !important;
-        transform: none !important;
     }
-    
-    /* FORCE GPU ACCELERATION FOR HEADER STABILITY */
-    .main-header {
-        transform: translate3d(0,0,0) !important;
-        backface-visibility: hidden !important;
-        perspective: 1000px !important;
+    /* Prevent layout shifts */
+    .stProgress {
+        transition: none !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;
+    .element-container {
+        transition: none !important;
     }
 </style>
 """, unsafe_allow_html=True)
@@ -132,10 +102,16 @@ 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 - FIXED with stable UI updates
 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
+    5. FIXED: Minimal UI updates to prevent header trembling
     """
 
     def __init__(self):
@@ -169,8 +145,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)
 
-    def run_optimized_simulation(self, G, mu, lambda_max_mean=None, status_callback=None):
-        """OPTIMIZED simulation with minimal but responsive UI updates"""
+        # Note: lambdamax will be set dynamically from .mat file in run_optimized_simulation
+
+    def run_optimized_simulation(self, G, mu, lambda_max_mean=None):
+        """Run optimized simulation - FIXED with minimal UI updates"""
         from scipy.integrate import solve_ivp
 
         # Set lambdamax from loaded data or use default
@@ -199,7 +177,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)
@@ -245,58 +225,55 @@ 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)")
 
-        # SAFE STATUS UPDATE: Use callback to update UI safely
-        if status_callback:
-            status_callback("🔄 Initializing bubble physics solver...")
+        # FIXED: Use single status placeholder instead of progress bar to prevent trembling
+        status_placeholder = st.empty()
+        status_placeholder.text("🔄 Starting simulation...")
 
-        # OPTIMIZED ODE solving with minimal updates
+        # 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
             )
 
-            if status_callback:
-                status_callback("⚙️ Processing simulation results...")
+            status_placeholder.text("⚙️ Processing results...")
 
         except Exception as e:
             print(f"BDF failed: {str(e)}, trying LSODA...")
-            if status_callback:
-                status_callback("🔄 Trying backup solver (LSODA)...")
+            status_placeholder.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)}")
-                if status_callback:
-                    status_callback("⚠️ Using analytical fallback...")
+                status_placeholder.empty()
                 return self.fast_fallback()
 
         if not sol.success:
             print(f"Solver failed: {sol.message}")
-            if status_callback:
-                status_callback("⚠️ Solver failed, using fallback...")
+            status_placeholder.empty()
             return self.fast_fallback()
 
         # Extract solution
         t_nondim = sol.t
         X_nondim = sol.y.T
+
         R_nondim = X_nondim[:, 0]
 
         # Filter valid solutions
@@ -306,8 +283,7 @@ class OptimizedBubbleSimulation:
 
         if len(t_nondim) < 10:
             print("Too few valid points, using fast fallback")
-            if status_callback:
-                status_callback("⚠️ Using analytical approximation...")
+            status_placeholder.empty()
             return self.fast_fallback()
 
         # Back to physical units
@@ -319,10 +295,12 @@ class OptimizedBubbleSimulation:
         t_newunit = t * scale
         R_newunit = R * scale
 
-        if status_callback:
-            status_callback("✅ Simulation completed successfully!")
+        # FIXED: Minimal final update and quick cleanup
+        status_placeholder.text("✅ Simulation complete!")
+        time.sleep(0.1)  # Reduced from 0.5 to 0.1 for faster UX
+        status_placeholder.empty()
 
-        print(f"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)")
 
@@ -330,7 +308,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])
@@ -516,7 +495,7 @@ class OptimizedBubbleSimulation:
 
 # Main Streamlit App
 def main():
-    # Header - ULTRA-STABLE with fixed positioning
+    # Header - FIXED with stable CSS
     st.markdown('<h1 class="main-header">🫧 Bubble Dynamics Transformer</h1>', unsafe_allow_html=True)
 
     # Initialize current page in session state
@@ -1392,7 +1371,7 @@ Ready for validation simulation!"""
 
 
 def show_validation():
-    """STABLE Validation interface with responsive feedback"""
+    """FIXED Validation interface with stable containers"""
     st.markdown('<h2 class="section-header">✅ Validation</h2>', unsafe_allow_html=True)
 
     if not st.session_state.processed_data:
@@ -1427,101 +1406,90 @@ def show_validation():
         if 'lambda_max_mean' in st.session_state:
             st.write(f"**λ_max:** {st.session_state.lambda_max_mean:.3f}")
 
-    # STABLE: Single button with immediate response
-    if st.button("🚀 Run Validation Simulation", type="primary", key="validation_button"):
-        # 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.")
-            return
-
-        # Create status display for user feedback
-        status_placeholder = st.empty()
-        results_container = st.container()
-
-        # Define status update callback
-        def update_status(message):
-            status_placeholder.info(f"**Status:** {message}")
-
-        # Initial status
-        update_status("🔄 Starting validation 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 with status callback
-            start_time = time.time()
-            t_sim, R_sim = bubble_sim.run_optimized_simulation(
-                G_value, mu_value, st.session_state.lambda_max_mean, 
-                status_callback=update_status
-            )
-            simulation_time = time.time() - start_time
+    # FIXED: Use stable containers to prevent layout shifts and header trembling
+    button_container = st.container()
+    results_container = st.empty()
 
-            # Clear status and show results
-            status_placeholder.empty()
-
-            # Store simulation results
-            st.session_state.t_sim = t_sim
-            st.session_state.R_sim = R_sim
-
-            with results_container:
-                # 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)
+    with button_container:
+        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.")
+                return
 
-                # 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}")
+            # Use the results container for all dynamic content to prevent header movement
+            with results_container.container():
+                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]
 
-                # Show detailed results (matching desktop GUI message)
-                validation_results = f"""**Validation Results (Optimized):**
+                        # 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}")
+
+                        # Show detailed results (matching desktop GUI message)
+                        validation_results = f"""**Validation Results (Optimized):**
 
 **Predicted Values:**
 - Shear Modulus (G): {G_value:.2e} Pa
@@ -1529,25 +1497,25 @@ def show_validation():
 - Lambda Max: {st.session_state.lambda_max_mean:.3f} (from .mat file)
 
 **Simulation Performance:**
-- Simulation Time: {simulation_time:.2f} seconds (optimized!)
+- 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."""
+simulated (line) R-t curves using predicted material properties.
+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_placeholder.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():