Update app.py

app.py

@@ -230,13 +230,22 @@ def setup_figure(env):
 
     return fig
 
+def format_number(num):
+    if num >= 1_000_000:
+        return f"{num/1_000_000:.1f}M"
+    elif num >= 1_000:
+        return f"{num/1_000:.1f}K"
+    else:
+        return str(num)
+
 # Streamlit app
-st.title("Advanced Cell Evolution Simulation")
+st.title("Continuous Cell Evolution Simulation")
 
-initial_cells = st.slider("Initial number of cells", 10, 500, 200)
-update_interval = st.slider("Update interval (seconds)", 0.01, 1.0, 0.05)  # Increased speed
+# Sidebar for controls and live statistics
+st.sidebar.header("Simulation Controls")
+initial_cells = st.sidebar.slider("Initial number of cells", 10, 500, 200)
+update_interval = st.sidebar.slider("Update interval (seconds)", 0.01, 1.0, 0.05)
 
-# Effect options
 st.sidebar.header("Environmental Effects")
 radiation = st.sidebar.checkbox("Radiation")
 predation = st.sidebar.checkbox("Predation")
@@ -248,62 +257,120 @@ effects = {
     "symbiosis": symbiosis
 }
 
-# Create placeholders for the chart and stop button
+# Live statistics placeholders
+st.sidebar.header("Live Statistics")
+total_cells_text = st.sidebar.empty()
+cell_type_breakdown = st.sidebar.empty()
+dominant_type_text = st.sidebar.empty()
+avg_energy_text = st.sidebar.empty()
+total_merges_text = st.sidebar.empty()
+
+# Event log
+st.sidebar.header("Event Log")
+event_log = deque(maxlen=10)  # Keep the last 10 events
+event_log_text = st.sidebar.empty()
+
+# Create placeholders for the chart
 chart_placeholder = st.empty()
-stop_button_placeholder = st.empty()
 
 # Initialize session state
 if 'running' not in st.session_state:
     st.session_state.running = False
+if 'total_merges' not in st.session_state:
+    st.session_state.total_merges = 0
+if 'env' not in st.session_state:
+    st.session_state.env = None
+if 'fig' not in st.session_state:
+    st.session_state.fig = None
 
 def toggle_simulation():
     st.session_state.running = not st.session_state.running
+    if st.session_state.running and st.session_state.env is None:
+        st.session_state.env = Environment(100, 100, effects)
+        for _ in range(initial_cells):
+            cell = Cell(random.uniform(0, st.session_state.env.width), random.uniform(0, st.session_state.env.height))
+            st.session_state.env.add_cell(cell)
+        st.session_state.fig = setup_figure(st.session_state.env)
 
 start_stop_button = st.button("Start/Stop Simulation", on_click=toggle_simulation)
 
-if st.session_state.running:
-    env = Environment(100, 100, effects)
-    for _ in range(initial_cells):
-        cell = Cell(random.uniform(0, env.width), random.uniform(0, env.height))
-        env.add_cell(cell)
-    
-    fig = setup_figure(env)
-    
-    while st.session_state.running:
-        for _ in range(4):  # Update 4 times per frame to increase simulation speed
-            env.update()
-        
-        with fig.batch_update():
-            cell_data, population_history, colors = env.get_visualization_data()
+def run_simulation():
+    while True:
+        if st.session_state.running:
+            for _ in range(4):  # Update 4 times per frame to increase simulation speed
+                initial_cell_count = len(st.session_state.env.cells)
+                st.session_state.env.update()
+                final_cell_count = len(st.session_state.env.cells)
+                
+                # Check for merges
+                if final_cell_count < initial_cell_count:
+                    merges = initial_cell_count - final_cell_count
+                    st.session_state.total_merges += merges
+                    event_log.appendleft(f"Time {st.session_state.env.time}: {merges} cell merge(s) occurred!")
+
+                # Check for new cell types
+                for cell in st.session_state.env.cells:
+                    if cell.cell_type not in st.session_state.env.population_history:
+                        event_log.appendleft(f"Time {st.session_state.env.time}: New cell type '{cell.cell_type}' emerged!")
+
+        time.sleep(update_interval)
+
+def update_chart():
+    while True:
+        if st.session_state.running and st.session_state.fig is not None:
+            with st.session_state.fig.batch_update():
+                cell_data, population_history, colors = st.session_state.env.get_visualization_data()
+                
+                # Update cell distribution
+                for i, (cell_type, data) in enumerate(cell_data.items()):
+                    st.session_state.fig.data[i].x = data["x"]
+                    st.session_state.fig.data[i].y = data["y"]
+                    st.session_state.fig.data[i].marker.size = data["size"]
+                
+                # Update total population
+                total_population = [sum(counts) for counts in zip(*population_history.values())]
+                st.session_state.fig.data[len(cell_data)].y = total_population
+                
+                # Update population by cell type
+                for i, (cell_type, counts) in enumerate(population_history.items()):
+                    st.session_state.fig.data[len(cell_data) + 1 + i].y = counts
+                
+                # Update organelle distribution
+                organelle_counts = {"nucleus": 0, "mitochondria": 0, "chloroplast": 0, "endoplasmic_reticulum": 0, "golgi_apparatus": 0}
+                for cell in st.session_state.env.cells:
+                    for organelle in cell.organelles:
+                        organelle_counts[organelle] += 1
+                st.session_state.fig.data[-1].y = list(organelle_counts.values())
+            
+            # Update live statistics
+            total_cells = len(st.session_state.env.cells)
+            total_cells_text.text(f"Total Cells: {format_number(total_cells)}")
+            
+            cell_type_counts = {cell_type: len([c for c in st.session_state.env.cells if c.cell_type == cell_type]) for cell_type in st.session_state.env.population_history.keys()}
+            cell_type_breakdown.text("Cell Type Breakdown:\n" + "\n".join([f"{cell_type}: {format_number(count)}" for cell_type, count in cell_type_counts.items()]))
             
-            # Update cell distribution
-            for i, (cell_type, data) in enumerate(cell_data.items()):
-                fig.data[i].x = data["x"]
-                fig.data[i].y = data["y"]
-                fig.data[i].marker.size = data["size"]
+            dominant_type = max(cell_type_counts, key=cell_type_counts.get)
+            dominant_type_text.text(f"Dominant Type: {dominant_type}")
             
-            # Update total population
-            total_population = [sum(counts) for counts in zip(*population_history.values())]
-            fig.data[len(cell_data)].y = total_population
+            avg_energy = sum(cell.energy for cell in st.session_state.env.cells) / total_cells if total_cells > 0 else 0
+            avg_energy_text.text(f"Avg Energy: {avg_energy:.2f}")
             
-            # Update population by cell type
-            for i, (cell_type, counts) in enumerate(population_history.items()):
-                fig.data[len(cell_data) + 1 + i].y = counts
+            total_merges_text.text(f"Total Merges: {st.session_state.total_merges}")
             
-            # Update organelle distribution
-            organelle_counts = {"nucleus": 0, "mitochondria": 0, "chloroplast": 0, "endoplasmic_reticulum": 0, "golgi_apparatus": 0}
-            for cell in env.cells:
-                for organelle in cell.organelles:
-                    organelle_counts[organelle] += 1
-            fig.data[-1].y = list(organelle_counts.values())
-        
-        chart_placeholder.plotly_chart(fig, use_container_width=True)
+            # Update event log
+            event_log_text.text("Recent Events:\n" + "\n".join(event_log))
+            
+            chart_placeholder.plotly_chart(st.session_state.fig, use_container_width=True)
+
         time.sleep(update_interval)
 
-        # Check if the stop button has been pressed
-        if not st.session_state.running:
-            break
+# Start the simulation and chart update threads
+simulation_thread = threading.Thread(target=run_simulation)
+chart_thread = threading.Thread(target=update_chart)
+
+simulation_thread.start()
+chart_thread.start()
 
-# Display final state if simulation has been stopped
-if not st.session_state.running and 'fig' in locals():
-    chart_placeholder.plotly_chart(fig, use_container_width=True)
+# Keep the main thread alive
+while True:
+    time.sleep(1)