Update src/streamlit_app.py

src/streamlit_app.py

@@ -1397,7 +1397,7 @@ Ready for validation simulation!"""
 
 
 def show_validation():
-    """ULTRA-STABLE Validation interface - NO TREMBLING GUARANTEED"""
+    """FIXED Validation interface - No trembling for Predicted Values and Metrics"""
     st.markdown('<h2 class="section-header">✅ Validation</h2>', unsafe_allow_html=True)
 
     if not st.session_state.processed_data:
@@ -1419,61 +1419,62 @@ def show_validation():
 
     st.subheader("🔬 Simulation vs Experimental Comparison")
 
+    # FIXED: Create completely static layout - render predicted values once and never change
     col1, col2 = st.columns([2, 1])
 
     with col2:
-        st.markdown("**Predicted Values:**")
-        # 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]
-
-        st.write(f"**G:** {G_value:.2e} Pa")
-        st.write(f"**μ:** {mu_value:.4f} Pa·s")
-        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():
+        # STATIC CONTAINER: Predicted values - never re-renders
+        predicted_values_container = st.container()
+        with predicted_values_container:
+            st.markdown("**Predicted Values:**")
+            # Extract values once and display statically
+            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]
+
+            # CRITICAL FIX: Use static markdown instead of dynamic st.write to prevent trembling
+            st.markdown(f"""
+            **G:** `{G_value:.2e} Pa`  
+            **μ:** `{mu_value:.4f} Pa·s`  
+            **λ_max:** `{st.session_state.lambda_max_mean:.3f}`
+            """)
+
+    # ISOLATED BUTTON: Completely separate from other content
+    button_container = st.container()
+    with button_container:
         run_simulation = st.button("🚀 Run Validation Simulation", type="primary", key="validation_button")
 
+    # SEPARATE CONTAINERS: Isolate dynamic content
+    status_container = st.empty()
+    results_container = st.empty()
+
     if run_simulation:
-        # Check required data (exactly like desktop GUI)
+        # Check required data
         if st.session_state.lambda_max_mean is None:
-            st.error("No lambda_max_mean loaded. Please load data first.")
+            status_container.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]
-
-                    # Initialize simulation
-                    bubble_sim = OptimizedBubbleSimulation()
+            # Show simple status message
+            status_container.info("🔄 Running simulation... Please wait.")
+            
+            try:
+                # Use already extracted values - no re-computation
+                # Initialize simulation
+                bubble_sim = OptimizedBubbleSimulation()
 
-                    # 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
+                # 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()
+                # Clear status
+                status_container.empty()
 
-                    # Store simulation results
-                    st.session_state.t_sim = t_sim
-                    st.session_state.R_sim = R_sim
+                # Store simulation results
+                st.session_state.t_sim = t_sim
+                st.session_state.R_sim = R_sim
 
-                    # Create comparison plot (exactly like desktop GUI)
+                # Show ALL results in one container to prevent trembling
+                with results_container.container():
+                    # Create comparison plot
                     fig, ax = plt.subplots(figsize=(10, 6))
 
                     ax.plot(st.session_state.t_interp_newunit, st.session_state.R_interp_newunit,
@@ -1486,7 +1487,8 @@ def show_validation():
                     ax.grid(True, alpha=0.3)
                     ax.legend()
 
-                    # Calculate error metrics (exactly like desktop GUI)
+                    # Calculate error metrics
+                    rmse = mae = max_error = 0
                     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])
@@ -1512,24 +1514,41 @@ def show_validation():
                     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):**
+                    # CRITICAL FIX: Use static markdown instead of st.metric() to prevent trembling
+                    st.markdown("### 📊 Validation Metrics")
+                    
+                    metric_col1, metric_col2, metric_col3 = st.columns(3)
+                    with metric_col1:
+                        st.markdown(f"""
+                        **RMSE**  
+                        `{rmse:.3f}`
+                        """)
+                    with metric_col2:
+                        st.markdown(f"""
+                        **MAE**  
+                        `{mae:.3f}`
+                        """)
+                    with metric_col3:
+                        st.markdown(f"""
+                        **Max Error**  
+                        `{max_error:.3f}`
+                        """)
+
+                    # Show detailed results using static markdown
+                    st.success("✅ Validation simulation completed!")
+                    
+                    st.info(f"""**Validation Results (Ultra-Optimized):**
 
 **Predicted Values:**
 - Shear Modulus (G): {G_value:.2e} Pa
 - Viscosity (μ): {mu_value:.4f} Pa·s
 - Lambda Max: {st.session_state.lambda_max_mean:.3f} (from .mat file)
 
+**Error Metrics:**
+- RMSE: {rmse:.3f}
+- MAE: {mae:.3f}
+- Max Error: {max_error:.3f}
+
 **Simulation Performance:**
 - Simulation Time: {simulation_time:.2f} seconds (ultra-fast!)
 - Simulated Points: {len(R_sim)}
@@ -1537,20 +1556,17 @@ def show_validation():
 
 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 ultra-optimized simulation with ZERO UI updates during execution.""")
 
-                    st.success("✅ Validation simulation completed!")
-                    st.info(validation_results)
-
-                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')}")
+            except Exception as e:
+                status_container.empty()
+                results_container.error(f"Simulation failed: {str(e)}")
+
+                with results_container.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():