Update app.py

app.py

@@ -4,30 +4,18 @@ import streamlit as st
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 import time
-import threading
-import queue
-
-
-
-# Your classes and functions...
 
 class Organelle:
     def __init__(self, type):
         self.type = type
 
-class Modification:
-    def __init__(self, name, effect):
-        self.name = name
-        self.effect = effect
-
 class Cell:
     def __init__(self, x, y, cell_type="prokaryote"):
         self.x = x
         self.y = y
         self.energy = 100
         self.cell_type = cell_type
-        self.organelles = []
-        self.modifications = []
+        self.organelles = set()
         self.size = 1
         self.color = "lightblue"
         self.division_threshold = 150
@@ -36,33 +24,32 @@ class Cell:
 
     def update_properties(self):
         if self.cell_type == "early_eukaryote":
-            self.organelles.append(Organelle("nucleus"))
+            self.organelles.add("nucleus")
             self.color = "green"
             self.size = 2
         elif self.cell_type == "advanced_eukaryote":
-            self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria")])
+            self.organelles.update(["nucleus", "mitochondria"])
             self.color = "red"
             self.size = 3
         elif self.cell_type == "plant_like":
-            self.organelles.extend([Organelle("nucleus"), Organelle("mitochondria"), Organelle("chloroplast")])
+            self.organelles.update(["nucleus", "mitochondria", "chloroplast"])
             self.color = "darkgreen"
             self.size = 4
+        elif self.cell_type == "complete":
+            self.organelles.update(["nucleus", "mitochondria", "chloroplast", "endoplasmic_reticulum", "golgi_apparatus"])
+            self.color = "purple"
+            self.size = 5
 
     def move(self, environment):
-        dx = random.uniform(-1, 1)
-        dy = random.uniform(-1, 1)
+        dx, dy = random.uniform(-1, 1), random.uniform(-1, 1)
         self.x = max(0, min(environment.width - 1, self.x + dx))
         self.y = max(0, min(environment.height - 1, self.y + dy))
         self.energy -= 0.5 * self.size
 
     def feed(self, environment):
         base_energy = environment.grid[int(self.y)][int(self.x)] * 0.1
-        if "chloroplast" in [org.type for org in self.organelles]:
+        if "chloroplast" in self.organelles:
             base_energy += environment.light_level * 2
-        
-        for mod in self.modifications:
-            base_energy *= mod.effect
-
         self.energy += base_energy
         environment.grid[int(self.y)][int(self.x)] *= 0.9
 
@@ -74,7 +61,6 @@ class Cell:
             self.energy /= 2
             new_cell = Cell(self.x, self.y, self.cell_type)
             new_cell.organelles = self.organelles.copy()
-            new_cell.modifications = self.modifications.copy()
             return new_cell
         return None
 
@@ -88,30 +74,17 @@ class Cell:
             new_cell_type = "early_eukaryote"
         elif self.cell_type == "early_eukaryote":
             new_cell_type = "advanced_eukaryote"
+        elif self.cell_type == "advanced_eukaryote":
+            new_cell_type = "plant_like"
+        elif self.cell_type == "plant_like":
+            new_cell_type = "complete"
 
-        new_cell = Cell(
-            (self.x + other.x) / 2,
-            (self.y + other.y) / 2,
-            new_cell_type
-        )
+        new_cell = Cell((self.x + other.x) / 2, (self.y + other.y) / 2, new_cell_type)
         new_cell.energy = self.energy + other.energy
-        new_cell.organelles = list(set(self.organelles + other.organelles))
-        new_cell.modifications = list(set(self.modifications + other.modifications))
+        new_cell.organelles = self.organelles.union(other.organelles)
         new_cell.update_properties()
         return new_cell
 
-    def acquire_modification(self):
-        possible_mods = [
-            Modification("Enhanced metabolism", 1.2),
-            Modification("Thick cell wall", 0.8),
-            Modification("Efficient energy storage", 1.1),
-            Modification("Rapid division", 0.9)
-        ]
-        new_mod = random.choice(possible_mods)
-        if new_mod not in self.modifications:
-            self.modifications.append(new_mod)
-            self.color = "purple"  # Visual indicator of modification
-
 class Environment:
     def __init__(self, width, height):
         self.width = width
@@ -122,7 +95,7 @@ class Environment:
         self.time = 0
         self.population_history = {
             "prokaryote": [], "early_eukaryote": [],
-            "advanced_eukaryote": [], "plant_like": [], "modified": []
+            "advanced_eukaryote": [], "plant_like": [], "complete": []
         }
 
     def add_cell(self, cell):
@@ -159,102 +132,89 @@ class Environment:
         self.cells.extend(new_cells)
         self.cells = [cell for cell in self.cells if cell not in cells_to_remove]
 
-        # Introduce mutations and modifications
-        for cell in self.cells:
-            if random.random() < 0.0001:  # 0.01% chance of mutation
-                if cell.cell_type == "early_eukaryote":
-                    cell.cell_type = "advanced_eukaryote"
-                elif cell.cell_type == "advanced_eukaryote" and random.random() < 0.5:
-                    cell.cell_type = "plant_like"
-                cell.update_properties()
-            
-            if random.random() < 0.0005:  # 0.05% chance of acquiring a modification
-                cell.acquire_modification()
-
         # Record population counts
         for cell_type in self.population_history.keys():
-            if cell_type != "modified":
-                count = len([cell for cell in self.cells if cell.cell_type == cell_type and not cell.modifications])
-            else:
-                count = len([cell for cell in self.cells if cell.modifications])
+            count = len([cell for cell in self.cells if cell.cell_type == cell_type])
             self.population_history[cell_type].append(count)
 
     def get_visualization_data(self):
-        cell_data = {
-            "prokaryote": {"x": [], "y": [], "size": [], "color": "lightblue", "symbol": "circle"},
-            "early_eukaryote": {"x": [], "y": [], "size": [], "color": "green", "symbol": "square"},
-            "advanced_eukaryote": {"x": [], "y": [], "size": [], "color": "red", "symbol": "diamond"},
-            "plant_like": {"x": [], "y": [], "size": [], "color": "darkgreen", "symbol": "star"},
-            "modified": {"x": [], "y": [], "size": [], "color": "purple", "symbol": "cross"}
-        }
+        cell_data = {cell_type: {"x": [], "y": [], "size": []} for cell_type in self.population_history.keys()}
+        colors = {"prokaryote": "lightblue", "early_eukaryote": "green", "advanced_eukaryote": "red", "plant_like": "darkgreen", "complete": "purple"}
 
         for cell in self.cells:
-            cell_type = "modified" if cell.modifications else cell.cell_type
-            cell_data[cell_type]["x"].append(cell.x)
-            cell_data[cell_type]["y"].append(cell.y)
-            cell_data[cell_type]["size"].append(cell.size * 3)
+            cell_data[cell.cell_type]["x"].append(cell.x)
+            cell_data[cell.cell_type]["y"].append(cell.y)
+            cell_data[cell.cell_type]["size"].append(cell.size * 3)
 
-        return cell_data, self.population_history
+        return cell_data, self.population_history, colors
 
 def setup_figure(env):
-    cell_types = ["prokaryote", "early_eukaryote", "advanced_eukaryote", "plant_like", "modified"]
-    fig = make_subplots(rows=2, cols=3, 
+    cell_types = list(env.population_history.keys())
+    fig = make_subplots(rows=2, cols=2, 
                         subplot_titles=("Cell Distribution", "Total Population", 
-                                        "Prokaryotes", "Early Eukaryotes", 
-                                        "Advanced Eukaryotes", "Plant-like & Modified"),
+                                        "Population by Cell Type", "Organelle Distribution"),
                         vertical_spacing=0.1,
                         horizontal_spacing=0.05)
 
+    cell_data, population_history, colors = env.get_visualization_data()
+
     # Cell distribution
-    for cell_type, data in env.get_visualization_data()[0].items():
+    for cell_type, data in cell_data.items():
         fig.add_trace(go.Scatter(
             x=data["x"], y=data["y"], mode='markers',
-            marker=dict(color=data["color"], size=data["size"], symbol=data["symbol"]),
+            marker=dict(color=colors[cell_type], size=data["size"]),
             name=cell_type
         ), row=1, col=1)
 
     # Total population over time
-    for cell_type, counts in env.population_history.items():
-        fig.add_trace(go.Scatter(y=counts, mode='lines', name=cell_type), row=1, col=2)
-
-    # Individual population charts
-    for i, cell_type in enumerate(cell_types):
-        if cell_type == "modified":
-            fig.add_trace(go.Scatter(y=env.population_history[cell_type], mode='lines', 
-                                     name=cell_type, line=dict(color="purple")), row=2, col=3)
-        elif cell_type == "plant_like":
-            fig.add_trace(go.Scatter(y=env.population_history[cell_type], mode='lines', 
-                                     name=cell_type, line=dict(color="darkgreen")), row=2, col=3)
-        else:
-            fig.add_trace(go.Scatter(y=env.population_history[cell_type], mode='lines', 
-                                     name=cell_type), row=2, col=i+1)
+    total_population = [sum(counts) for counts in zip(*population_history.values())]
+    fig.add_trace(go.Scatter(y=total_population, mode='lines', name="Total"), row=1, col=2)
+
+    # Population by cell type
+    for cell_type, counts in population_history.items():
+        fig.add_trace(go.Scatter(y=counts, mode='lines', name=cell_type, line=dict(color=colors[cell_type])), row=2, col=1)
+
+    # 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.add_trace(go.Bar(x=list(organelle_counts.keys()), y=list(organelle_counts.values()), name="Organelles"), row=2, col=2)
 
     fig.update_xaxes(title_text="X", row=1, col=1)
     fig.update_yaxes(title_text="Y", row=1, col=1)
     fig.update_xaxes(title_text="Time", row=1, col=2)
     fig.update_yaxes(title_text="Population", row=1, col=2)
-
-    for i in range(1, 4):
-        fig.update_xaxes(title_text="Time", row=2, col=i)
-        fig.update_yaxes(title_text="Population", row=2, col=i)
+    fig.update_xaxes(title_text="Time", row=2, col=1)
+    fig.update_yaxes(title_text="Population", row=2, col=1)
+    fig.update_xaxes(title_text="Organelle", row=2, col=2)
+    fig.update_yaxes(title_text="Count", row=2, col=2)
 
     fig.update_layout(height=800, width=1200, title_text="Advanced Cell Evolution Simulation")
 
     return fig
 
-# Create a queue to communicate between the threads
-q = queue.Queue()
-
 # Streamlit app
 st.title("Advanced Cell Evolution Simulation")
 
 initial_cells = st.slider("Initial number of cells", 10, 200, 100)
 update_interval = st.slider("Update interval (seconds)", 0.1, 5.0, 1.0)
 
-# Create a placeholder for the chart
+# Create placeholders for the chart and stop button
 chart_placeholder = st.empty()
+stop_button_placeholder = st.empty()
+
+# Initialize session state
+if 'running' not in st.session_state:
+    st.session_state.running = False
+
+def toggle_simulation():
+    st.session_state.running = not st.session_state.running
 
-if st.button("Start Simulation"):
+start_stop_button = st.button("Start/Stop Simulation", on_click=toggle_simulation)
+
+if st.session_state.running:
     env = Environment(100, 100)
     for _ in range(initial_cells):
         cell = Cell(random.uniform(0, env.width), random.uniform(0, env.height))
@@ -262,23 +222,40 @@ if st.button("Start Simulation"):
     
     fig = setup_figure(env)
     
-    for _ in range(100):  # Run for 100 steps
+    while st.session_state.running:
         env.update()
         
         with fig.batch_update():
-            cell_data, population_history = env.get_visualization_data()
+            cell_data, population_history, colors = env.get_visualization_data()
+            
+            # 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"]
             
+            # Update total population
+            total_population = [sum(counts) for counts in zip(*population_history.values())]
+            fig.data[len(cell_data)].y = total_population
+            
+            # Update population by cell type
             for i, (cell_type, counts) in enumerate(population_history.items()):
-                fig.data[i+5].y = counts
-                if cell_type != "modified" and cell_type != "plant_like":
-                    fig.data[i+10].y = counts
-                else:
-                    fig.data[13].y = population_history["plant_like"]
-                    fig.data[14].y = population_history["modified"]
+                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 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)
-        time.sleep(update_interval)
+        time.sleep(update_interval)
+
+        # Check if the stop button has been pressed
+        if not st.session_state.running:
+            break
+
+# 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)