Update app.py

app.py

@@ -8,6 +8,8 @@ from PIL import Image
 import time
 import io
 import sys
+import tempfile
+import platform
 
 # Set page config with wider layout
 st.set_page_config(
@@ -65,6 +67,18 @@ st.markdown("""
         padding: 10px;
         margin: 10px 0;
     }
+    .stWarning {
+        background-color: #fff3cd;
+        padding: 10px;
+        border-left: 3px solid #ffc107;
+        margin: 10px 0;
+    }
+    .stSuccess {
+        background-color: #d4edda;
+        padding: 10px;
+        border-left: 3px solid #28a745;
+        margin: 10px 0;
+    }
 </style>
 """, unsafe_allow_html=True)
 
@@ -76,48 +90,14 @@ current_dir = os.getcwd()
 output_dir = os.path.join(current_dir, "output")
 os.makedirs(output_dir, exist_ok=True)
 
-# Compile the C++ code at runtime
+# Path to the C++ source file and executable
 cpp_file = os.path.join(current_dir, "app.cpp")
 executable = os.path.join(current_dir, "eigen_analysis")
-
-# Check if cpp file exists and compile if necessary
-if not os.path.exists(cpp_file):
-    st.error(f"C++ source file not found at: {cpp_file}")
-    st.stop()
-
-# Compile the C++ code with the right OpenCV libraries
-if not os.path.exists(executable) or st.sidebar.button("Recompile C++ Code"):
-    with st.sidebar:
-        with st.spinner("Compiling C++ code..."):
-            compile_commands = [
-                f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv4` -std=c++11",
-                f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv` -std=c++11",
-                f"g++ -o {executable} {cpp_file} -I/usr/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11"
-            ]
-            
-            compiled = False
-            for cmd in compile_commands:
-                compile_result = subprocess.run(
-                    cmd, 
-                    shell=True,
-                    capture_output=True,
-                    text=True
-                )
-                
-                if compile_result.returncode == 0:
-                    compiled = True
-                    break
-            
-            if not compiled:
-                st.error("All compilation attempts failed. Please check the system requirements.")
-                st.stop()
-            
-            # Make sure the executable is executable
-            os.chmod(executable, 0o755)
-            st.success("C++ code compiled successfully")
+if platform.system() == "Windows":
+    executable += ".exe"
 
 # Helper function for running commands with better debugging
-def run_command(cmd, show_output=True):
+def run_command(cmd, show_output=True, timeout=None):
     cmd_str = " ".join(cmd)
     if show_output:
         st.code(f"Running command: {cmd_str}", language="bash")
@@ -129,29 +109,91 @@ def run_command(cmd, show_output=True):
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             text=True,
-            check=True
+            check=False,
+            timeout=timeout
         )
         
-        if show_output:
-            st.write("Command completed successfully.")
-            if result.stdout:
-                st.text("Output:")
-                st.code(result.stdout)
-                
-        return True, result.stdout, result.stderr
-        
-    except subprocess.CalledProcessError as e:
-        if show_output:
-            st.error(f"Command failed with return code {e.returncode}")
-            st.error(f"Command: {cmd_str}")
-            st.error(f"Error output: {e.stderr}")
-        return False, e.stdout, e.stderr
+        if result.returncode == 0:
+            if show_output:
+                st.success("Command completed successfully.")
+                if result.stdout and show_output:
+                    with st.expander("Command Output"):
+                        st.code(result.stdout)
+            return True, result.stdout, result.stderr
+        else:
+            if show_output:
+                st.error(f"Command failed with return code {result.returncode}")
+                st.error(f"Command: {cmd_str}")
+                st.error(f"Error output: {result.stderr}")
+            return False, result.stdout, result.stderr
     
+    except subprocess.TimeoutExpired:
+        if show_output:
+            st.error(f"Command timed out after {timeout} seconds")
+        return False, "", f"Command timed out after {timeout} seconds"
     except Exception as e:
         if show_output:
             st.error(f"Error executing command: {str(e)}")
         return False, "", str(e)
 
+# Check if C++ source file exists
+if not os.path.exists(cpp_file):
+    with open(cpp_file, "w") as f:
+        st.warning(f"C++ source file not found at: {cpp_file}")
+        st.info("Creating an empty file. Please paste the C++ code into this file and recompile.")
+        f.write("// Paste the C++ code here and recompile\n")
+
+# Compile the C++ code with the right OpenCV libraries
+st.sidebar.title("Compiler Settings")
+need_compile = not os.path.exists(executable) or st.sidebar.button("Recompile C++ Code")
+
+if need_compile:
+    with st.sidebar:
+        with st.spinner("Compiling C++ code..."):
+            # Try to detect the OpenCV installation
+            opencv_detection_cmd = ["pkg-config", "--cflags", "--libs", "opencv4"]
+            opencv_found, opencv_flags, _ = run_command(opencv_detection_cmd, show_output=False)
+            
+            compile_commands = []
+            
+            if opencv_found:
+                compile_commands.append(
+                    f"g++ -o {executable} {cpp_file} {opencv_flags.strip()} -std=c++11"
+                )
+            else:
+                # Try different OpenCV configurations
+                compile_commands = [
+                    f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv4` -std=c++11",
+                    f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv` -std=c++11",
+                    f"g++ -o {executable} {cpp_file} -I/usr/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11",
+                    f"g++ -o {executable} {cpp_file} -I/usr/local/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11"
+                ]
+            
+            compiled = False
+            compile_output = ""
+            
+            for cmd in compile_commands:
+                st.text(f"Trying: {cmd}")
+                success, stdout, stderr = run_command(cmd.split(), show_output=False)
+                compile_output += f"Command: {cmd}\nOutput: {stdout}\nError: {stderr}\n\n"
+                
+                if success:
+                    compiled = True
+                    st.success(f"Successfully compiled with: {cmd}")
+                    break
+            
+            if not compiled:
+                st.error("All compilation attempts failed.")
+                with st.expander("Compilation Details"):
+                    st.code(compile_output)
+                st.stop()
+            
+            # Make sure the executable is executable
+            if platform.system() != "Windows":
+                os.chmod(executable, 0o755)
+            
+            st.success("C++ code compiled successfully!")
+
 # Create tabs for different analyses
 tab1, tab2 = st.tabs(["Eigenvalue Analysis", "Im(s) vs z Analysis"])
 
@@ -212,6 +254,16 @@ with tab1:
             
             # Debug mode
             debug_mode = st.checkbox("Debug Mode", value=False, key="eig_debug")
+            
+            # Timeout setting
+            timeout_seconds = st.number_input(
+                "Computation timeout (seconds)", 
+                min_value=30, 
+                max_value=3600, 
+                value=300,
+                help="Maximum time allowed for computation before timeout",
+                key="eig_timeout"
+            )
         
         # Generate button
         eig_generate_button = st.button("Generate Eigenvalue Analysis", 
@@ -263,34 +315,52 @@ with tab1:
                     status_text.text("Running eigenvalue analysis...")
                     
                     if debug_mode:
-                        success, stdout, stderr = run_command(cmd, True)
+                        success, stdout, stderr = run_command(cmd, True, timeout=timeout_seconds)
+                        # Process stdout for progress updates
+                        if success:
+                            progress_bar.progress(1.0)
                     else:
                         # Start the process with pipe for stdout to read progress
                         process = subprocess.Popen(
                             cmd,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
-                            text=True
+                            text=True,
+                            bufsize=1,
+                            universal_newlines=True
                         )
                         
                         # Track progress from stdout
                         success = True
+                        stdout_lines = []
+                        
+                        start_time = time.time()
                         while True:
+                            # Check for timeout
+                            if time.time() - start_time > timeout_seconds:
+                                process.kill()
+                                status_text.error(f"Computation timed out after {timeout_seconds} seconds")
+                                success = False
+                                break
+                                
+                            # Try to read a line (non-blocking)
                             line = process.stdout.readline()
                             if not line and process.poll() is not None:
                                 break
                                 
-                            if line.startswith("PROGRESS:"):
-                                try:
-                                    # Update progress bar
-                                    progress_value = float(line.split(":")[1].strip())
-                                    progress_bar.progress(progress_value)
-                                    status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
-                                except:
-                                    pass
-                            elif line:
-                                status_text.text(line.strip())
-                                
+                            if line:
+                                stdout_lines.append(line)
+                                if line.startswith("PROGRESS:"):
+                                    try:
+                                        # Update progress bar
+                                        progress_value = float(line.split(":")[1].strip())
+                                        progress_bar.progress(progress_value)
+                                        status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
+                                    except:
+                                        pass
+                                elif line:
+                                    status_text.text(line.strip())
+                                    
                         # Get the return code and stderr
                         returncode = process.poll()
                         stderr = process.stderr.read()
@@ -298,6 +368,8 @@ with tab1:
                         if returncode != 0:
                             success = False
                             st.error(f"Error executing the analysis: {stderr}")
+                            with st.expander("Error Details"):
+                                st.code(stderr)
                     
                     if success:
                         progress_bar.progress(1.0)
@@ -308,157 +380,177 @@ with tab1:
                             st.error(f"Output file not created: {data_file}")
                             st.stop()
                         
-                        # Load the results from the JSON file
-                        with open(data_file, 'r') as f:
-                            data = json.load(f)
-                        
-                        # Extract data
-                        beta_values = np.array(data['beta_values'])
-                        max_eigenvalues = np.array(data['max_eigenvalues'])
-                        min_eigenvalues = np.array(data['min_eigenvalues'])
-                        theoretical_max = np.array(data['theoretical_max'])
-                        theoretical_min = np.array(data['theoretical_min'])
-                        
-                        # Create an interactive plot using Plotly
-                        fig = go.Figure()
-                        
-                        # Add traces for each line
-                        fig.add_trace(go.Scatter(
-                            x=beta_values, 
-                            y=max_eigenvalues,
-                            mode='lines+markers',
-                            name='Empirical Max Eigenvalue',
-                            line=dict(color='rgb(220, 60, 60)', width=3),
-                            marker=dict(
-                                symbol='circle',
-                                size=8,
-                                color='rgb(220, 60, 60)',
-                                line=dict(color='white', width=1)
-                            ),
-                            hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Max</extra>'
-                        ))
-                        
-                        fig.add_trace(go.Scatter(
-                            x=beta_values, 
-                            y=min_eigenvalues,
-                            mode='lines+markers',
-                            name='Empirical Min Eigenvalue',
-                            line=dict(color='rgb(60, 60, 220)', width=3),
-                            marker=dict(
-                                symbol='circle',
-                                size=8,
-                                color='rgb(60, 60, 220)',
-                                line=dict(color='white', width=1)
-                            ),
-                            hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Min</extra>'
-                        ))
-                        
-                        fig.add_trace(go.Scatter(
-                            x=beta_values, 
-                            y=theoretical_max,
-                            mode='lines+markers',
-                            name='Theoretical Max Function',
-                            line=dict(color='rgb(30, 180, 30)', width=3),
-                            marker=dict(
-                                symbol='diamond',
-                                size=8,
-                                color='rgb(30, 180, 30)',
-                                line=dict(color='white', width=1)
-                            ),
-                            hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Max</extra>'
-                        ))
-                        
-                        fig.add_trace(go.Scatter(
-                            x=beta_values, 
-                            y=theoretical_min,
-                            mode='lines+markers',
-                            name='Theoretical Min Function',
-                            line=dict(color='rgb(180, 30, 180)', width=3),
-                            marker=dict(
-                                symbol='diamond',
-                                size=8,
-                                color='rgb(180, 30, 180)',
-                                line=dict(color='white', width=1)
-                            ),
-                            hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Min</extra>'
-                        ))
-                        
-                        # Configure layout for better appearance
-                        fig.update_layout(
-                            title={
-                                'text': f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}',
-                                'font': {'size': 24, 'color': '#1E88E5'},
-                                'y': 0.95,
-                                'x': 0.5,
-                                'xanchor': 'center',
-                                'yanchor': 'top'
-                            },
-                            xaxis={
-                                'title': 'β Parameter',
-                                'titlefont': {'size': 18, 'color': '#424242'},
-                                'tickfont': {'size': 14},
-                                'gridcolor': 'rgba(220, 220, 220, 0.5)',
-                                'showgrid': True
-                            },
-                            yaxis={
-                                'title': 'Eigenvalues',
-                                'titlefont': {'size': 18, 'color': '#424242'},
-                                'tickfont': {'size': 14},
-                                'gridcolor': 'rgba(220, 220, 220, 0.5)',
-                                'showgrid': True
-                            },
-                            plot_bgcolor='rgba(240, 240, 240, 0.8)',
-                            paper_bgcolor='rgba(249, 249, 249, 0.8)',
-                            hovermode='closest',
-                            legend={
-                                'font': {'size': 14},
-                                'bgcolor': 'rgba(255, 255, 255, 0.9)',
-                                'bordercolor': 'rgba(200, 200, 200, 0.5)',
-                                'borderwidth': 1
-                            },
-                            margin={'l': 60, 'r': 30, 't': 100, 'b': 60},
-                            height=600,
-                            annotations=[
-                                {
-                                    'text': f"Max Function: max{{k ∈ (0,∞)}} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]",
-                                    'xref': 'paper', 'yref': 'paper',
-                                    'x': 0.02, 'y': 0.02,
-                                    'showarrow': False,
-                                    'font': {'size': 12, 'color': 'rgb(30, 180, 30)'},
-                                    'bgcolor': 'rgba(255, 255, 255, 0.9)',
-                                    'bordercolor': 'rgb(30, 180, 30)',
-                                    'borderwidth': 1,
-                                    'borderpad': 4
+                        try:
+                            # Load the results from the JSON file
+                            with open(data_file, 'r') as f:
+                                data = json.load(f)
+                            
+                            # Extract data
+                            beta_values = np.array(data['beta_values'])
+                            max_eigenvalues = np.array(data['max_eigenvalues'])
+                            min_eigenvalues = np.array(data['min_eigenvalues'])
+                            theoretical_max = np.array(data['theoretical_max'])
+                            theoretical_min = np.array(data['theoretical_min'])
+                            
+                            # Create an interactive plot using Plotly
+                            fig = go.Figure()
+                            
+                            # Add traces for each line
+                            fig.add_trace(go.Scatter(
+                                x=beta_values, 
+                                y=max_eigenvalues,
+                                mode='lines+markers',
+                                name='Empirical Max Eigenvalue',
+                                line=dict(color='rgb(220, 60, 60)', width=3),
+                                marker=dict(
+                                    symbol='circle',
+                                    size=8,
+                                    color='rgb(220, 60, 60)',
+                                    line=dict(color='white', width=1)
+                                ),
+                                hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Max</extra>'
+                            ))
+                            
+                            fig.add_trace(go.Scatter(
+                                x=beta_values, 
+                                y=min_eigenvalues,
+                                mode='lines+markers',
+                                name='Empirical Min Eigenvalue',
+                                line=dict(color='rgb(60, 60, 220)', width=3),
+                                marker=dict(
+                                    symbol='circle',
+                                    size=8,
+                                    color='rgb(60, 60, 220)',
+                                    line=dict(color='white', width=1)
+                                ),
+                                hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Min</extra>'
+                            ))
+                            
+                            fig.add_trace(go.Scatter(
+                                x=beta_values, 
+                                y=theoretical_max,
+                                mode='lines+markers',
+                                name='Theoretical Max Function',
+                                line=dict(color='rgb(30, 180, 30)', width=3),
+                                marker=dict(
+                                    symbol='diamond',
+                                    size=8,
+                                    color='rgb(30, 180, 30)',
+                                    line=dict(color='white', width=1)
+                                ),
+                                hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Max</extra>'
+                            ))
+                            
+                            fig.add_trace(go.Scatter(
+                                x=beta_values, 
+                                y=theoretical_min,
+                                mode='lines+markers',
+                                name='Theoretical Min Function',
+                                line=dict(color='rgb(180, 30, 180)', width=3),
+                                marker=dict(
+                                    symbol='diamond',
+                                    size=8,
+                                    color='rgb(180, 30, 180)',
+                                    line=dict(color='white', width=1)
+                                ),
+                                hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Min</extra>'
+                            ))
+                            
+                            # Configure layout for better appearance
+                            fig.update_layout(
+                                title={
+                                    'text': f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}',
+                                    'font': {'size': 24, 'color': '#1E88E5'},
+                                    'y': 0.95,
+                                    'x': 0.5,
+                                    'xanchor': 'center',
+                                    'yanchor': 'top'
+                                },
+                                xaxis={
+                                    'title': 'β Parameter',
+                                    'titlefont': {'size': 18, 'color': '#424242'},
+                                    'tickfont': {'size': 14},
+                                    'gridcolor': 'rgba(220, 220, 220, 0.5)',
+                                    'showgrid': True
                                 },
-                                {
-                                    'text': f"Min Function: min{{t ∈ (-1/a,0)}} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]",
-                                    'xref': 'paper', 'yref': 'paper',
-                                    'x': 0.55, 'y': 0.02,
-                                    'showarrow': False,
-                                    'font': {'size': 12, 'color': 'rgb(180, 30, 180)'},
+                                yaxis={
+                                    'title': 'Eigenvalues',
+                                    'titlefont': {'size': 18, 'color': '#424242'},
+                                    'tickfont': {'size': 14},
+                                    'gridcolor': 'rgba(220, 220, 220, 0.5)',
+                                    'showgrid': True
+                                },
+                                plot_bgcolor='rgba(240, 240, 240, 0.8)',
+                                paper_bgcolor='rgba(249, 249, 249, 0.8)',
+                                hovermode='closest',
+                                legend={
+                                    'font': {'size': 14},
                                     'bgcolor': 'rgba(255, 255, 255, 0.9)',
-                                    'bordercolor': 'rgb(180, 30, 180)',
-                                    'borderwidth': 1,
-                                    'borderpad': 4
-                                }
-                            ]
-                        )
-                        
-                        # Add custom modebar buttons
-                        fig.update_layout(
-                            modebar_add=[
-                                'drawline', 'drawopenpath', 'drawclosedpath',
-                                'drawcircle', 'drawrect', 'eraseshape'
-                            ],
-                            modebar_remove=['lasso2d', 'select2d'],
-                            dragmode='zoom'
-                        )
-                        
-                        # Clear progress container
-                        progress_container.empty()
-                        
-                        # Display the interactive plot in Streamlit
-                        st.plotly_chart(fig, use_container_width=True)
+                                    'bordercolor': 'rgba(200, 200, 200, 0.5)',
+                                    'borderwidth': 1
+                                },
+                                margin={'l': 60, 'r': 30, 't': 100, 'b': 60},
+                                height=600,
+                                annotations=[
+                                    {
+                                        'text': f"Max Function: max{{k ∈ (0,∞)}} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]",
+                                        'xref': 'paper', 'yref': 'paper',
+                                        'x': 0.02, 'y': 0.02,
+                                        'showarrow': False,
+                                        'font': {'size': 12, 'color': 'rgb(30, 180, 30)'},
+                                        'bgcolor': 'rgba(255, 255, 255, 0.9)',
+                                        'bordercolor': 'rgb(30, 180, 30)',
+                                        'borderwidth': 1,
+                                        'borderpad': 4
+                                    },
+                                    {
+                                        'text': f"Min Function: min{{t ∈ (-1/a,0)}} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]",
+                                        'xref': 'paper', 'yref': 'paper',
+                                        'x': 0.55, 'y': 0.02,
+                                        'showarrow': False,
+                                        'font': {'size': 12, 'color': 'rgb(180, 30, 180)'},
+                                        'bgcolor': 'rgba(255, 255, 255, 0.9)',
+                                        'bordercolor': 'rgb(180, 30, 180)',
+                                        'borderwidth': 1,
+                                        'borderpad': 4
+                                    }
+                                ]
+                            )
+                            
+                            # Add custom modebar buttons
+                            fig.update_layout(
+                                modebar_add=[
+                                    'drawline', 'drawopenpath', 'drawclosedpath',
+                                    'drawcircle', 'drawrect', 'eraseshape'
+                                ],
+                                modebar_remove=['lasso2d', 'select2d'],
+                                dragmode='zoom'
+                            )
+                            
+                            # Clear progress container
+                            progress_container.empty()
+                            
+                            # Display the interactive plot in Streamlit
+                            st.plotly_chart(fig, use_container_width=True)
+                            
+                            # Display statistics
+                            with st.expander("Statistics"):
+                                col1, col2 = st.columns(2)
+                                with col1:
+                                    st.write("### Eigenvalue Statistics")
+                                    st.write(f"Max empirical value: {max_eigenvalues.max():.6f}")
+                                    st.write(f"Min empirical value: {min_eigenvalues.min():.6f}")
+                                with col2:
+                                    st.write("### Theoretical Values")
+                                    st.write(f"Max theoretical value: {theoretical_max.max():.6f}")
+                                    st.write(f"Min theoretical value: {theoretical_min.min():.6f}")
+                                
+                        except json.JSONDecodeError as e:
+                            st.error(f"Error parsing JSON results: {str(e)}")
+                            if os.path.exists(data_file):
+                                with open(data_file, 'r') as f:
+                                    content = f.read()
+                                st.code(content[:1000] + "..." if len(content) > 1000 else content)
                 
                 except Exception as e:
                     st.error(f"An error occurred: {str(e)}")
@@ -625,6 +717,16 @@ with tab2:
         # Debug mode
         cubic_debug_mode = st.checkbox("Debug Mode", value=False, key="cubic_debug")
         
+        # Timeout setting
+        cubic_timeout = st.number_input(
+            "Computation timeout (seconds)", 
+            min_value=10, 
+            max_value=600, 
+            value=60,
+            help="Maximum time allowed for computation before timeout",
+            key="cubic_timeout"
+        )
+        
         # Show cubic equation
         st.markdown('<div class="math-box">', unsafe_allow_html=True)
         st.markdown("### Cubic Equation")
@@ -678,13 +780,12 @@ with tab2:
                     status_text.text("Calculating Im(s) vs z values...")
                     
                     if cubic_debug_mode:
-                        success, stdout, stderr = run_command(cmd, True)
+                        success, stdout, stderr = run_command(cmd, True, timeout=cubic_timeout)
                     else:
                         # Run the command with our helper function
-                        result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-                        success = result.returncode == 0
+                        success, stdout, stderr = run_command(cmd, False, timeout=cubic_timeout)
                         if not success:
-                            st.error(f"Error executing cubic analysis: {result.stderr}")
+                            st.error(f"Error executing cubic analysis: {stderr}")
                     
                     if success:
                         status_text.text("Calculations complete! Generating visualization...")
@@ -694,132 +795,140 @@ with tab2:
                             st.error(f"Output file not created: {data_file}")
                             st.stop()
                         
-                        # Load the results from the JSON file
-                        with open(data_file, 'r') as f:
-                            data = json.load(f)
-                        
-                        # Extract data
-                        z_values = np.array(data['z_values'])
-                        ims_values1 = np.array(data['ims_values1'])
-                        ims_values2 = np.array(data['ims_values2'])
-                        ims_values3 = np.array(data['ims_values3'])
-                        
-                        # Create an interactive plot using Plotly
-                        fig = go.Figure()
-                        
-                        # Add traces for each root's imaginary part
-                        fig.add_trace(go.Scatter(
-                            x=z_values, 
-                            y=ims_values1,
-                            mode='lines',
-                            name='Im(s₁)',
-                            line=dict(color='rgb(220, 60, 60)', width=3),
-                            hovertemplate='z: %{x:.3f}<br>Im(s₁): %{y:.6f}<extra>Root 1</extra>'
-                        ))
-                        
-                        fig.add_trace(go.Scatter(
-                            x=z_values, 
-                            y=ims_values2,
-                            mode='lines',
-                            name='Im(s₂)',
-                            line=dict(color='rgb(60, 60, 220)', width=3),
-                            hovertemplate='z: %{x:.3f}<br>Im(s₂): %{y:.6f}<extra>Root 2</extra>'
-                        ))
-                        
-                        fig.add_trace(go.Scatter(
-                            x=z_values, 
-                            y=ims_values3,
-                            mode='lines',
-                            name='Im(s₃)',
-                            line=dict(color='rgb(30, 180, 30)', width=3),
-                            hovertemplate='z: %{x:.3f}<br>Im(s₃): %{y:.6f}<extra>Root 3</extra>'
-                        ))
-                        
-                        # Configure layout for better appearance
-                        fig.update_layout(
-                            title={
-                                'text': f'Im(s) vs z Analysis: a={cubic_a}, y={cubic_y}, β={cubic_beta}',
-                                'font': {'size': 24, 'color': '#1E88E5'},
-                                'y': 0.95,
-                                'x': 0.5,
-                                'xanchor': 'center',
-                                'yanchor': 'top'
-                            },
-                            xaxis={
-                                'title': 'z (logarithmic scale)',
-                                'titlefont': {'size': 18, 'color': '#424242'},
-                                'tickfont': {'size': 14},
-                                'gridcolor': 'rgba(220, 220, 220, 0.5)',
-                                'showgrid': True,
-                                'type': 'log'  # Use logarithmic scale for better visualization
-                            },
-                            yaxis={
-                                'title': 'Im(s)',
-                                'titlefont': {'size': 18, 'color': '#424242'},
-                                'tickfont': {'size': 14},
-                                'gridcolor': 'rgba(220, 220, 220, 0.5)',
-                                'showgrid': True
-                            },
-                            plot_bgcolor='rgba(240, 240, 240, 0.8)',
-                            paper_bgcolor='rgba(249, 249, 249, 0.8)',
-                            hovermode='closest',
-                            legend={
-                                'font': {'size': 14},
-                                'bgcolor': 'rgba(255, 255, 255, 0.9)',
-                                'bordercolor': 'rgba(200, 200, 200, 0.5)',
-                                'borderwidth': 1
-                            },
-                            margin={'l': 60, 'r': 30, 't': 100, 'b': 60},
-                            height=600,
-                            annotations=[
-                                {
-                                    'text': f"Cubic Equation: {cubic_a}zs³ + [{cubic_a+1}z+{cubic_a}(1-{cubic_y})]s² + [z+{cubic_a+1}-{cubic_y}-{cubic_y*cubic_beta}({cubic_a-1})]s + 1 = 0",
-                                    'xref': 'paper', 'yref': 'paper',
-                                    'x': 0.5, 'y': 0.02,
-                                    'showarrow': False,
-                                    'font': {'size': 12, 'color': 'black'},
+                        try:
+                            # Load the results from the JSON file
+                            with open(data_file, 'r') as f:
+                                data = json.load(f)
+                            
+                            # Extract data
+                            z_values = np.array(data['z_values'])
+                            ims_values1 = np.array(data['ims_values1'])
+                            ims_values2 = np.array(data['ims_values2'])
+                            ims_values3 = np.array(data['ims_values3'])
+                            
+                            # Create an interactive plot using Plotly
+                            fig = go.Figure()
+                            
+                            # Add traces for each root's imaginary part
+                            fig.add_trace(go.Scatter(
+                                x=z_values, 
+                                y=ims_values1,
+                                mode='lines',
+                                name='Im(s₁)',
+                                line=dict(color='rgb(220, 60, 60)', width=3),
+                                hovertemplate='z: %{x:.3f}<br>Im(s₁): %{y:.6f}<extra>Root 1</extra>'
+                            ))
+                            
+                            fig.add_trace(go.Scatter(
+                                x=z_values, 
+                                y=ims_values2,
+                                mode='lines',
+                                name='Im(s₂)',
+                                line=dict(color='rgb(60, 60, 220)', width=3),
+                                hovertemplate='z: %{x:.3f}<br>Im(s₂): %{y:.6f}<extra>Root 2</extra>'
+                            ))
+                            
+                            fig.add_trace(go.Scatter(
+                                x=z_values, 
+                                y=ims_values3,
+                                mode='lines',
+                                name='Im(s₃)',
+                                line=dict(color='rgb(30, 180, 30)', width=3),
+                                hovertemplate='z: %{x:.3f}<br>Im(s₃): %{y:.6f}<extra>Root 3</extra>'
+                            ))
+                            
+                            # Configure layout for better appearance
+                            fig.update_layout(
+                                title={
+                                    'text': f'Im(s) vs z Analysis: a={cubic_a}, y={cubic_y}, β={cubic_beta}',
+                                    'font': {'size': 24, 'color': '#1E88E5'},
+                                    'y': 0.95,
+                                    'x': 0.5,
+                                    'xanchor': 'center',
+                                    'yanchor': 'top'
+                                },
+                                xaxis={
+                                    'title': 'z (logarithmic scale)',
+                                    'titlefont': {'size': 18, 'color': '#424242'},
+                                    'tickfont': {'size': 14},
+                                    'gridcolor': 'rgba(220, 220, 220, 0.5)',
+                                    'showgrid': True,
+                                    'type': 'log'  # Use logarithmic scale for better visualization
+                                },
+                                yaxis={
+                                    'title': 'Im(s)',
+                                    'titlefont': {'size': 18, 'color': '#424242'},
+                                    'tickfont': {'size': 14},
+                                    'gridcolor': 'rgba(220, 220, 220, 0.5)',
+                                    'showgrid': True
+                                },
+                                plot_bgcolor='rgba(240, 240, 240, 0.8)',
+                                paper_bgcolor='rgba(249, 249, 249, 0.8)',
+                                hovermode='closest',
+                                legend={
+                                    'font': {'size': 14},
                                     'bgcolor': 'rgba(255, 255, 255, 0.9)',
-                                    'bordercolor': 'rgba(0, 0, 0, 0.5)',
-                                    'borderwidth': 1,
-                                    'borderpad': 4,
-                                    'align': 'center'
-                                }
-                            ]
-                        )
-                        
-                        # Add custom modebar buttons
-                        fig.update_layout(
-                            modebar_add=[
-                                'drawline', 'drawopenpath', 'drawclosedpath',
-                                'drawcircle', 'drawrect', 'eraseshape'
-                            ],
-                            modebar_remove=['lasso2d', 'select2d'],
-                            dragmode='zoom'
-                        )
-                        
-                        # Clear progress container
-                        progress_container.empty()
-                        
-                        # Display the interactive plot in Streamlit
-                        st.plotly_chart(fig, use_container_width=True)
-                        
-                        # Add explanation text
-                        st.markdown("""
-                        ### Explanation of the Analysis
-                        
-                        This plot shows the imaginary parts of the three roots (s₁, s₂, s₃) of the cubic equation as a function of z. 
-                        The cubic equation being solved is:
-                        
-                        ```
-                        zas³ + [z(a+1)+a(1-y)]s² + [z+(a+1)-y-yβ(a-1)]s + 1 = 0
-                        ```
-                        
-                        Where a, y, and β are parameters you can adjust in the control panel. The imaginary parts of the roots represent 
-                        oscillatory behavior in the system.
-                        
-                        - When Im(s) = 0, the root is purely real
-                        - When Im(s) ≠ 0, the root has an oscillatory component
-                        """)
+                                    'bordercolor': 'rgba(200, 200, 200, 0.5)',
+                                    'borderwidth': 1
+                                },
+                                margin={'l': 60, 'r': 30, 't': 100, 'b': 60},
+                                height=600,
+                                annotations=[
+                                    {
+                                        'text': f"Cubic Equation: {cubic_a}zs³ + [{cubic_a+1}z+{cubic_a}(1-{cubic_y})]s² + [z+{cubic_a+1}-{cubic_y}-{cubic_y*cubic_beta}({cubic_a-1})]s + 1 = 0",
+                                        'xref': 'paper', 'yref': 'paper',
+                                        'x': 0.5, 'y': 0.02,
+                                        'showarrow': False,
+                                        'font': {'size': 12, 'color': 'black'},
+                                        'bgcolor': 'rgba(255, 255, 255, 0.9)',
+                                        'bordercolor': 'rgba(0, 0, 0, 0.5)',
+                                        'borderwidth': 1,
+                                        'borderpad': 4,
+                                        'align': 'center'
+                                    }
+                                ]
+                            )
+                            
+                            # Add custom modebar buttons
+                            fig.update_layout(
+                                modebar_add=[
+                                    'drawline', 'drawopenpath', 'drawclosedpath',
+                                    'drawcircle', 'drawrect', 'eraseshape'
+                                ],
+                                modebar_remove=['lasso2d', 'select2d'],
+                                dragmode='zoom'
+                            )
+                            
+                            # Clear progress container
+                            progress_container.empty()
+                            
+                            # Display the interactive plot in Streamlit
+                            st.plotly_chart(fig, use_container_width=True)
+                            
+                            # Add explanation text
+                            st.markdown("""
+                            ### Explanation of the Analysis
+                            
+                            This plot shows the imaginary parts of the three roots (s₁, s₂, s₃) of the cubic equation as a function of z. 
+                            The cubic equation being solved is:
+                            
+                            ```
+                            zas³ + [z(a+1)+a(1-y)]s² + [z+(a+1)-y-yβ(a-1)]s + 1 = 0
+                            ```
+                            
+                            Where a, y, and β are parameters you can adjust in the control panel. The imaginary parts of the roots represent 
+                            oscillatory behavior in the system.
+                            
+                            - When Im(s) = 0, the root is purely real
+                            - When Im(s) ≠ 0, the root has an oscillatory component
+                            """)
+                            
+                        except json.JSONDecodeError as e:
+                            st.error(f"Error parsing JSON results: {str(e)}")
+                            if os.path.exists(data_file):
+                                with open(data_file, 'r') as f:
+                                    content = f.read()
+                                st.code(content[:1000] + "..." if len(content) > 1000 else content)
                 
                 except Exception as e:
                     st.error(f"An error occurred: {str(e)}")
@@ -919,4 +1028,18 @@ with tab2:
                 # Show placeholder
                 st.info("👈 Set parameters and click 'Generate Im(s) vs z Analysis' to create a visualization.")
         
-        st.markdown('</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+# Add footer with instructions
+st.markdown("""
+---
+### Instructions for Using the Dashboard
+
+1. **Select a tab** at the top to choose between Eigenvalue Analysis and Im(s) vs z Analysis
+2. **Adjust parameters** in the left panel to configure your analysis
+3. **Click the Generate button** to run the analysis with the selected parameters
+4. **Explore the results** in the interactive plot
+5. For advanced users, you can enable **Debug Mode** to see detailed output
+
+If you encounter any issues with compilation, try clicking the "Recompile C++ Code" button in the sidebar.
+""")