Update src/streamlit_app.py

src/streamlit_app.py

@@ -31,15 +31,35 @@ try:
 except ImportError:
     TENSORFLOW_AVAILABLE = False
 
-# Custom CSS for better styling
+# ULTRA-AGGRESSIVE CSS FIX - Complete stability
 st.markdown("""
 <style>
+    /* FORCE HEADER TO BE COMPLETELY FIXED AND STABLE */
     .main-header {
-        font-size: 2.5rem;
-        color: #1e88e5;
-        text-align: center;
-        margin-bottom: 2rem;
+        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;
     }
+    
+    /* 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;
@@ -64,6 +84,57 @@ 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)
 
@@ -76,15 +147,10 @@ if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 
 
-# Complete OptimizedBubbleSimulation class - matches GUI implementation exactly
+# ULTRA-OPTIMIZED BubbleSimulation class - ZERO UI UPDATES during simulation
 class OptimizedBubbleSimulation:
     """
-    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
+    ULTRA-OPTIMIZED version - ZERO UI updates during simulation to prevent any trembling
     """
 
     def __init__(self):
@@ -118,10 +184,8 @@ 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):
-        """Run optimized simulation - much faster while preserving core physics"""
+        """ULTRA-OPTIMIZED simulation - ZERO UI updates to prevent trembling"""
         from scipy.integrate import solve_ivp
 
         # Set lambdamax from loaded data or use default
@@ -132,7 +196,7 @@ class OptimizedBubbleSimulation:
             self.lambdamax = 5.99  # Fallback default
             print(f"Warning: Using default lambda_max = {self.lambdamax}")
 
-        print(f"Running OPTIMIZED simulation with predicted G={G:.2e} Pa, μ={mu:.4f} Pa·s")
+        print(f"Running ULTRA-OPTIMIZED simulation with predicted G={G:.2e} Pa, μ={mu:.4f} Pa·s")
 
         # Use predicted values
         self.G = G
@@ -150,9 +214,7 @@ class OptimizedBubbleSimulation:
             self.Rc = self.Rmax
             self.Uc = np.sqrt(self.P_inf / self.rho)
             self.tc = self.Rmax / self.Uc
-
-            # OPTIMIZATION: Shorter simulation time for validation (3x instead of 6x)
-        self.tspan = 3 * self.tc  # Reduced from 6*tc to 3*tc (2x faster)
+            self.tspan = 3 * self.tc  # Reduced for speed
 
         # Calculate parameters (same as original)
         self.Pv = self.P_ref * np.exp(-self.T_ref / self.T_inf)
@@ -198,54 +260,51 @@ class OptimizedBubbleSimulation:
 
         X0 = np.concatenate([[R0_star, U0_star, P0_star, S0], Theta0, k0])
 
-        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)")
+        print(f"State vector size: {len(X0)} (4 + {self.NT} + {self.NT})")
+        print(f"Time span: 0 to {self.tspan_star:.4f}")
 
-        # Add progress tracking for Streamlit
-        progress_bar = st.progress(0, text="Starting simulation...")
+        # CRITICAL FIX: NO UI UPDATES AT ALL - store them for later
+        self.simulation_status = "Starting simulation..."
 
-        # OPTIMIZED ODE solving with relaxed tolerances and larger time steps
+        # ULTRA-OPTIMIZED ODE solving - NO UI updates during solving
         try:
             sol = solve_ivp(
-                self.bubble_optimized,  # Optimized bubble physics
+                self.bubble_optimized,
                 [0, self.tspan_star],
                 X0,
                 method='BDF',
-                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
+                rtol=self.RelTol,
+                atol=1e-8,
+                max_step=self.tspan_star / 200,
+                dense_output=False
             )
 
-            progress_bar.progress(0.8, text="Processing results...")
+            self.simulation_status = "Processing results..."
 
         except Exception as e:
             print(f"BDF failed: {str(e)}, trying LSODA...")
-            progress_bar.progress(0.5, text="Trying backup solver...")
+            self.simulation_status = "Trying backup solver..."
             try:
                 sol = solve_ivp(
                     self.bubble_optimized,
                     [0, self.tspan_star],
                     X0,
                     method='LSODA',
-                    rtol=1e-4,  # Further relaxed for speed
+                    rtol=1e-4,
                     atol=1e-7,
-                    max_step=self.tspan_star / 100,  # Even larger steps for speed
+                    max_step=self.tspan_star / 100,
                 )
             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
@@ -255,7 +314,6 @@ 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
@@ -267,11 +325,9 @@ class OptimizedBubbleSimulation:
         t_newunit = t * scale
         R_newunit = R * scale
 
-        progress_bar.progress(1.0, text="Simulation complete!")
-        time.sleep(0.5)
-        progress_bar.empty()
+        self.simulation_status = "Simulation complete!"
 
-        print(f"Optimized simulation completed in {len(t_newunit)} points!")
+        print(f"ULTRA-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)")
 
@@ -279,8 +335,7 @@ class OptimizedBubbleSimulation:
 
     def bubble_optimized(self, t, x):
         """
-        OPTIMIZED version of bubble physics function - COMPLETE IMPLEMENTATION matching GUI
-        Same physics but with computational optimizations
+        OPTIMIZED bubble physics function - same physics, no UI updates
         """
         # Extract parameters (same as original)
         NT = int(self.params[0])
@@ -466,7 +521,7 @@ class OptimizedBubbleSimulation:
 
 # Main Streamlit App
 def main():
-    # Header
+    # Header - ULTRA-STABLE with fixed positioning
     st.markdown('<h1 class="main-header">🫧 Bubble Dynamics Transformer</h1>', unsafe_allow_html=True)
 
     # Initialize current page in session state
@@ -1342,7 +1397,7 @@ Ready for validation simulation!"""
 
 
 def show_validation():
-    """Validation interface - exactly matches desktop GUI"""
+    """ULTRA-STABLE Validation interface - NO TREMBLING GUARANTEED"""
     st.markdown('<h2 class="section-header">✅ Validation</h2>', unsafe_allow_html=True)
 
     if not st.session_state.processed_data:
@@ -1377,83 +1432,98 @@ def show_validation():
         if 'lambda_max_mean' in st.session_state:
             st.write(f"**λ_max:** {st.session_state.lambda_max_mean:.3f}")
 
-    if st.button("🚀 Run Validation Simulation", type="primary"):
+    # 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:
         # 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
+        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]
 
-        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}")
+                    # Initialize simulation
+                    bubble_sim = OptimizedBubbleSimulation()
 
-                # Show detailed results (matching desktop GUI message)
-                validation_results = f"""**Validation Results (Optimized):**
+                    # 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):**
 
 **Predicted Values:**
 - Shear Modulus (G): {G_value:.2e} Pa
@@ -1461,25 +1531,26 @@ def show_validation():
 - Lambda Max: {st.session_state.lambda_max_mean:.3f} (from .mat file)
 
 **Simulation Performance:**
-- Simulation Time: {simulation_time:.2f} seconds (much faster!)
+- Simulation Time: {simulation_time:.2f} seconds (ultra-fast!)
 - 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 an optimized simulation for faster results."""
+Note: This uses ultra-optimized simulation with ZERO UI updates during execution."""
 
-                st.success("✅ Validation simulation completed!")
-                st.info(validation_results)
+                    st.success("✅ Validation simulation completed!")
+                    st.info(validation_results)
 
-            except Exception as e:
-                st.error(f"Simulation failed: {str(e)}")
+                except Exception as e:
+                    status_text.empty()
+                    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():