simulation

app.py

@@ -1,4 +1,759 @@
+# app.py
 import streamlit as st
+import numpy as np
+import random
+import copy
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go # Using graph_objects for more control over the grid
+# import matplotlib.pyplot as plt # No longer needed for grid
+# import matplotlib.colors # No longer needed for grid
+import time # For the delay in continuous run
+
+# --- Simulation Core Classes ---
+
+class Cell:
+    """Base class for all cells."""
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y # Represents ROW index in grid (origin top-left)
+
+class CancerCell(Cell):
+    """Represents a cancer cell."""
+    CELL_TYPE = 1 # Grid representation
+    LABEL = 'Cancer'
+    COLOR = 'red'
+    def __init__(self, x, y, growth_prob, metastasis_prob, resistance, mutation_rate):
+        super().__init__(x, y)
+        self.growth_prob = growth_prob
+        self.metastasis_prob = metastasis_prob
+        self.resistance = resistance # 0.0 (susceptible) to 1.0 (fully resistant)
+        self.mutation_rate = mutation_rate
+        self.is_alive = True
+
+    def attempt_division(self, sim):
+        """Attempt to divide into an adjacent empty cell."""
+        if random.random() < self.growth_prob:
+            neighbors = sim.get_neighbors(self.x, self.y)
+            empty_neighbors = [(nx, ny) for nx, ny, cell_type in neighbors if cell_type == 0]
+            if empty_neighbors:
+                nx, ny = random.choice(empty_neighbors)
+                # Create a new cell with possibly mutated properties
+                new_cell = copy.deepcopy(self)
+                new_cell.x, new_cell.y = nx, ny
+                new_cell.mutate() # Mutate the offspring
+                return new_cell
+        return None
+
+    def attempt_metastasis(self, sim):
+        """Attempt to move to a random empty cell on the grid."""
+        if random.random() < self.metastasis_prob:
+            empty_cells = np.argwhere(sim.grid == 0)
+            if len(empty_cells) > 0:
+                new_y, new_x = random.choice(empty_cells) # Note: numpy argwhere returns (row, col) -> (y, x)
+                # Return the new position for the simulation to handle the move
+                return (int(new_x), int(new_y)) # Convert numpy types to int
+        return None
+
+    def mutate(self):
+        """Potentially mutate resistance and growth probability."""
+        if random.random() < self.mutation_rate:
+            # Mutate resistance slightly
+            self.resistance += random.uniform(-0.1, 0.1)
+            self.resistance = max(0.0, min(1.0, self.resistance)) # Keep within [0, 1]
+        if random.random() < self.mutation_rate:
+             # Mutate growth prob slightly
+            self.growth_prob += random.uniform(-0.05, 0.05)
+            self.growth_prob = max(0.0, min(1.0, self.growth_prob)) # Keep within [0, 1]
+
+    def check_drug_effect(self, drug_effect_base, drug_resistance_interaction):
+        """Check if the drug kills this cell."""
+        effective_drug = drug_effect_base * max(0, (1.0 - self.resistance * drug_resistance_interaction))
+        if random.random() < effective_drug:
+            self.is_alive = False
+            return True # Killed by drug
+        return False
+
+
+class ImmuneCell(Cell):
+    """Represents an immune cell."""
+    CELL_TYPE = 2 # Grid representation
+    LABEL = 'Immune'
+    COLOR = 'blue'
+    def __init__(self, x, y, base_kill_prob, movement_prob, lifespan, activation_boost):
+        super().__init__(x, y)
+        self.base_kill_prob = base_kill_prob
+        self.movement_prob = movement_prob
+        self.lifespan = lifespan
+        self.activation_boost = activation_boost # Added boost when activated by drug
+        self.steps_alive = 0
+        self.is_activated = False # Can be temporarily boosted by drug
+        self.is_alive = True
+
+    def attempt_move(self, sim):
+        """Attempt to move to a random adjacent cell (can be empty or occupied)."""
+        if random.random() < self.movement_prob:
+            neighbors = sim.get_neighbors(self.x, self.y, radius=1, include_self=False)
+            potential_moves = [(nx, ny) for nx, ny, _ in neighbors]
+            if potential_moves:
+                 # Prioritize moving towards cancer cells slightly
+                cancer_neighbors = [(nx, ny) for nx, ny, cell_type in neighbors if cell_type == CancerCell.CELL_TYPE]
+                if cancer_neighbors and random.random() < 0.5: # 50% chance to prioritize cancer
+                     nx, ny = random.choice(cancer_neighbors)
+                else:
+                    nx, ny = random.choice(potential_moves)
+                 # Return the new position for the simulation to handle the move
+                return (nx, ny)
+        return None
+
+    def attempt_kill(self, sim):
+        """Attempt to kill adjacent cancer cells."""
+        killed_coords = []
+        neighbors = sim.get_neighbors(self.x, self.y)
+        cancer_neighbors = [(nx, ny) for nx, ny, cell_type in neighbors if cell_type == CancerCell.CELL_TYPE]
+
+        current_kill_prob = self.base_kill_prob
+        if self.is_activated:
+            current_kill_prob += self.activation_boost
+            current_kill_prob = min(1.0, current_kill_prob) # Cap at 1.0
+
+        for nx, ny in cancer_neighbors:
+            if random.random() < current_kill_prob:
+                target_cell = sim.get_cell_at(nx, ny)
+                if target_cell and isinstance(target_cell, CancerCell) and target_cell.is_alive:
+                    target_cell.is_alive = False
+                    killed_coords.append((nx, ny))
+        return killed_coords # Return coords of killed cells
+
+    def step(self):
+        """Increment age and check lifespan."""
+        self.steps_alive += 1
+        if self.steps_alive >= self.lifespan:
+            self.is_alive = False
+        self.is_activated = False # Reset activation each step unless reactivated
+
+    def activate_by_drug(self, drug_immune_boost_prob):
+         """Potentially activate based on drug presence."""
+         if random.random() < drug_immune_boost_prob:
+             self.is_activated = True
+
+
+class Simulation:
+    """Manages the simulation grid and cells."""
+    def __init__(self, params):
+        self.params = params
+        self.grid_size = params['grid_size']
+        self.grid = np.zeros((self.grid_size, self.grid_size), dtype=int)
+        self.cells = {} # Using dict {(x, y): cell_obj} for faster lookup
+        self.history = [] # To store cell counts over time
+        self.current_step = 0
+        self._initialize_cells()
+        self._record_history() # Record initial state
+
+    def _initialize_cells(self):
+        """Place initial cells on the grid."""
+        center_x, center_y = self.grid_size // 2, self.grid_size // 2
+
+        # Initial Cancer Cells (cluster in the center)
+        radius = max(1, int(np.sqrt(self.params['initial_cancer_cells']) / 2))
+        count = 0
+        placed_coords = set() # Keep track of where we placed cells initially
+        for r in range(radius + 2): # Search slightly larger radius if needed
+             for x in range(center_x - r, center_x + r + 1):
+                 for y in range(center_y - r, center_y + r + 1):
+                     if count >= self.params['initial_cancer_cells']: break
+                     if 0 <= x < self.grid_size and 0 <= y < self.grid_size:
+                         coords = (x,y)
+                         if self.grid[y, x] == 0 and coords not in placed_coords: # Ensure cell is placed in empty spot
+                            cell = CancerCell(x, y,
+                                              self.params['cancer_growth_prob'],
+                                              self.params['cancer_metastasis_prob'],
+                                              self.params['cancer_initial_resistance'],
+                                              self.params['cancer_mutation_rate'])
+                            self.grid[y, x] = CancerCell.CELL_TYPE
+                            self.cells[coords] = cell
+                            placed_coords.add(coords)
+                            count += 1
+                 if count >= self.params['initial_cancer_cells']: break
+             if count >= self.params['initial_cancer_cells']: break
+
+
+        # Initial Immune Cells (randomly distributed)
+        immune_count = 0
+        attempts = 0 # Prevent infinite loop if grid is too full
+        max_attempts = self.grid_size * self.grid_size * 2
+        while immune_count < self.params['initial_immune_cells'] and attempts < max_attempts:
+            x, y = random.randint(0, self.grid_size - 1), random.randint(0, self.grid_size - 1)
+            coords = (x,y)
+            if self.grid[y, x] == 0 and coords not in placed_coords: # Place only in empty spots
+                cell = ImmuneCell(x, y,
+                                  self.params['immune_base_kill_prob'],
+                                  self.params['immune_movement_prob'],
+                                  self.params['immune_lifespan'],
+                                  self.params['drug_immune_activation_boost'])
+                self.grid[y, x] = ImmuneCell.CELL_TYPE
+                self.cells[coords] = cell
+                placed_coords.add(coords)
+                immune_count += 1
+            attempts += 1
+        if attempts >= max_attempts and immune_count < self.params['initial_immune_cells']:
+             st.warning(f"Could only place {immune_count}/{self.params['initial_immune_cells']} immune cells due to space constraints.")
+
+
+    def get_neighbors(self, x, y, radius=1, include_self=False):
+        """Get neighbors within a radius, handling grid boundaries."""
+        neighbors = []
+        for dx in range(-radius, radius + 1):
+            for dy in range(-radius, radius + 1):
+                if not include_self and dx == 0 and dy == 0:
+                    continue
+                nx, ny = x + dx, y + dy
+                # Check boundaries (no wrap-around)
+                if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size:
+                    neighbors.append((nx, ny, self.grid[ny, nx]))
+        return neighbors
+
+    def get_cell_at(self, x, y):
+        """Retrieve cell object at given coordinates."""
+        return self.cells.get((x, y), None)
+
+    def _apply_drug_effects(self):
+        """Apply drug effects: killing cancer cells and activating immune cells."""
+        killed_by_drug = []
+        immune_cells_to_activate = []
+
+        # Iterate through a copy of keys because dict size might change
+        for coords, cell in list(self.cells.items()):
+            if isinstance(cell, CancerCell) and cell.is_alive:
+                if cell.check_drug_effect(self.params['drug_effect_base'], self.params['drug_resistance_interaction']):
+                     killed_by_drug.append(coords)
+                     # Check for nearby immune cells to activate
+                     neighbors = self.get_neighbors(cell.x, cell.y, radius=self.params['drug_immune_activation_radius'])
+                     for nx, ny, cell_type in neighbors:
+                         if cell_type == ImmuneCell.CELL_TYPE:
+                             immune_cell = self.get_cell_at(nx, ny)
+                             if immune_cell and immune_cell.is_alive:
+                                 immune_cells_to_activate.append(immune_cell)
+
+        # Apply activation (using a set to avoid duplicate activations if multiple cancer cells are nearby)
+        for immune_cell in set(immune_cells_to_activate):
+             immune_cell.activate_by_drug(self.params['drug_immune_boost_prob']) # Pass prob here
+
+        return killed_by_drug
+
+    def _immune_cell_actions(self):
+        """Handle immune cell movement and killing actions."""
+        immune_moves = {} # {old_coords: new_coords}
+        killed_by_immune = []
+
+        # Iterate through a copy of keys
+        immune_cells_list = [cell for cell in self.cells.values() if isinstance(cell, ImmuneCell) and cell.is_alive]
+        random.shuffle(immune_cells_list) # Randomize order of action
+
+        for cell in immune_cells_list:
+             if not cell.is_alive: continue
+
+             # 1. Aging
+             cell.step()
+             if not cell.is_alive: continue # Died of old age
+
+             # 2. Attempt Kill
+             killed_coords = cell.attempt_kill(self)
+             killed_by_immune.extend(killed_coords)
+
+             # 3. Attempt Move (only if it didn't die)
+             new_pos = cell.attempt_move(self)
+             if new_pos:
+                nx, ny = new_pos
+                # Check if target is empty OR occupied by a cancer cell immune cell can kill/displace
+                # Prevent moving onto another immune cell's intended spot in this step
+                # Simplification: allow overlap for now, let update handle conflict
+                if new_pos not in immune_moves.values(): # Avoid multiple immune cells targetting same spot
+                   immune_moves[(cell.x, cell.y)] = new_pos
+
+
+        return immune_moves, killed_by_immune
+
+    def _cancer_cell_actions(self):
+        """Handle cancer cell division, metastasis, and mutation."""
+        new_cancer_cells = []
+        cancer_moves = {} # {old_coords: new_coords} for metastasis
+
+        # Iterate through a copy of keys
+        cancer_cells_list = [cell for cell in self.cells.values() if isinstance(cell, CancerCell) and cell.is_alive]
+        random.shuffle(cancer_cells_list) # Randomize order
+
+        for cell in cancer_cells_list:
+            if not cell.is_alive: continue # Could have been killed earlier in the step
+
+            # 1. Mutation (apply first, affects division/metastasis below)
+            # Moved mutation inside attempt_division/metastasis for offspring only in prev ver, let's keep it there.
+            # Parent mutation should also occur
+            cell.mutate() # Parent mutates regardless of division/metastasis
+
+            # 2. Attempt Division
+            offspring = cell.attempt_division(self) # Offspring inherits parent's (possibly mutated) state and then mutates itself
+            if offspring:
+                 # Check if the target spot is still empty (could have been taken by metastasis/immune move)
+                 # This check will happen more definitively in _update_grid_and_cells
+                 new_cancer_cells.append(offspring)
+
+            # 3. Attempt Metastasis (only if division didn't occur?) Let's allow both for now.
+            new_pos = cell.attempt_metastasis(self)
+            if new_pos:
+                # Check if the target spot is still empty AND not targeted by another metastasis
+                # Defer final check to _update_grid_and_cells
+                if new_pos not in cancer_moves.values(): # Avoid multiple metastases targeting same spot
+                   cancer_moves[(cell.x, cell.y)] = new_pos
+
+        return new_cancer_cells, cancer_moves
+
+
+    def _update_grid_and_cells(self, killed_coords_list, immune_moves, cancer_moves, new_cancer_cells):
+        """Update the grid and cell dictionary based on actions."""
+
+        # 1. Process deaths first
+        all_killed_coords = set()
+        for coords_list in killed_coords_list:
+            all_killed_coords.update(coords_list)
+
+        # Also add immune cells that died of old age
+        for coords, cell in list(self.cells.items()):
+             if isinstance(cell, ImmuneCell) and not cell.is_alive:
+                 all_killed_coords.add(coords)
+
+        for x, y in all_killed_coords:
+            if (x, y) in self.cells:
+                self.grid[y, x] = 0
+                if (x, y) in self.cells: # Check again, might be double-killed?
+                    del self.cells[(x, y)]
+
+        # --- Resolve Move Conflicts & Update ---
+        # Priority: Immune > Cancer Metastasis. If conflict, immune wins, cancer move fails.
+        # If immune A wants to move to B, and immune C wants to move to B, one fails randomly.
+        # If cancer A wants to move to B, and cancer C wants to move to B, one fails randomly.
+        # If immune A wants to move to B, and cancer C wants to move to B, immune wins.
+
+        occupied_targets = set()
+        resolved_immune_moves = {} # {old_coords: new_coords}
+        resolved_cancer_moves = {} # {old_coords: new_coords}
+
+        # Shuffle move order for fairness in conflicts
+        immune_move_items = list(immune_moves.items())
+        random.shuffle(immune_move_items)
+        cancer_move_items = list(cancer_moves.items())
+        random.shuffle(cancer_move_items)
+
+        # Process immune moves first
+        for old_coords, new_coords in immune_move_items:
+            if old_coords not in self.cells: continue # Cell died before moving
+            if new_coords not in occupied_targets:
+                target_cell = self.get_cell_at(new_coords[0], new_coords[1])
+                # Allow move if target is empty, or is a cancer cell (implicit displacement/kill)
+                if target_cell is None or isinstance(target_cell, CancerCell):
+                     resolved_immune_moves[old_coords] = new_coords
+                     occupied_targets.add(new_coords)
+                # else: blocked by another immune cell already there or moving there
+
+        # Process cancer metastasis moves
+        for old_coords, new_coords in cancer_move_items:
+            if old_coords not in self.cells: continue # Cell died before moving
+            if new_coords not in occupied_targets:
+                 target_cell = self.get_cell_at(new_coords[0], new_coords[1])
+                 # Allow move ONLY if target is empty
+                 if target_cell is None:
+                     resolved_cancer_moves[old_coords] = new_coords
+                     occupied_targets.add(new_coords)
+                 # else: blocked by existing cell or an immune cell moving there
+
+
+        # Apply moves: remove old, add new
+        moved_cells_buffer = {} # Store {new_coords: cell} before adding back
+
+        for old_coords, new_coords in resolved_immune_moves.items():
+            if old_coords in self.cells: # Check if cell still exists
+                cell = self.cells.pop(old_coords)
+                self.grid[old_coords[1], old_coords[0]] = 0
+                cell.x, cell.y = new_coords
+                moved_cells_buffer[new_coords] = cell
+
+        for old_coords, new_coords in resolved_cancer_moves.items():
+             if old_coords in self.cells: # Check if cell still exists
+                cell = self.cells.pop(old_coords)
+                self.grid[old_coords[1], old_coords[0]] = 0
+                cell.x, cell.y = new_coords
+                moved_cells_buffer[new_coords] = cell
+
+        # Add moved cells back, handling displacement
+        for new_coords, cell in moved_cells_buffer.items():
+            # If an immune cell lands on a cancer cell's spot, the cancer cell should be gone.
+            if isinstance(cell, ImmuneCell) and new_coords in self.cells and isinstance(self.cells[new_coords], CancerCell):
+                 del self.cells[new_coords] # Remove the displaced cancer cell
+
+            # Place the moved cell
+            self.cells[new_coords] = cell
+            self.grid[new_coords[1], new_coords[0]] = cell.CELL_TYPE
+
+
+        # 3. Process births (add new cancer cells)
+        # Shuffle order for fairness if multiple births target same location (unlikely but possible)
+        random.shuffle(new_cancer_cells)
+        added_cells_count = 0
+        for cell in new_cancer_cells:
+            coords = (cell.x, cell.y)
+            # Final check if the spot is truly empty *after* deaths and moves
+            if self.grid[cell.y, cell.x] == 0 and coords not in self.cells:
+                self.grid[cell.y, cell.x] = CancerCell.CELL_TYPE
+                self.cells[coords] = cell
+                added_cells_count += 1
+            # else: Birth failed due to space conflict
+
+    def step(self):
+        """Perform one step of the simulation."""
+        # Check if simulation should stop before proceeding
+        cancer_count = sum(1 for cell in self.cells.values() if isinstance(cell, CancerCell))
+        if cancer_count == 0 and self.current_step > 0: # Check after at least one step
+             st.session_state.final_message = "Cancer eliminated!"
+             return False # Stop simulation
+        if self.current_step >= self.params['max_steps']:
+             st.session_state.final_message = "Maximum steps reached."
+             return False # Stop simulation
+        if not self.cells: # Stop if absolutely no cells left for some reason
+             st.session_state.final_message = "No cells remaining."
+             return False
+
+        # --- Action Phase ---
+        # 1. Drug effects (kill cancer, activate immune)
+        killed_by_drug = self._apply_drug_effects()
+
+        # 2. Immune cell actions (move, kill, age)
+        immune_moves, killed_by_immune = self._immune_cell_actions()
+
+        # 3. Cancer cell actions (divide, metastasize) - Mutation happens within these
+        new_cancer_cells, cancer_moves = self._cancer_cell_actions()
+
+        # --- Update Phase ---
+        # Consolidate killed cells list
+        all_killed_this_step = [killed_by_drug, killed_by_immune]
+
+        # Apply all changes to grid and cell list
+        self._update_grid_and_cells(all_killed_this_step, immune_moves, cancer_moves, new_cancer_cells)
+
+        # --- End Step ---
+        self.current_step += 1
+        self._record_history()
+
+
+        return True # Continue simulation
+
+
+    def _record_history(self):
+        """Record the number of each cell type."""
+        cancer_count = sum(1 for cell in self.cells.values() if isinstance(cell, CancerCell))
+        immune_count = sum(1 for cell in self.cells.values() if isinstance(cell, ImmuneCell))
+        avg_resistance = 0
+        if cancer_count > 0:
+            avg_resistance = sum(cell.resistance for cell in self.cells.values() if isinstance(cell, CancerCell)) / cancer_count
+
+        self.history.append({
+            'Step': self.current_step,
+            'Cancer Cells': cancer_count,
+            'Immune Cells': immune_count,
+            'Average Resistance': avg_resistance
+        })
+
+    def get_history_df(self):
+        """Return the recorded history as a Pandas DataFrame."""
+        return pd.DataFrame(self.history)
+
+    def get_plotly_grid_data(self):
+        """Prepare data for Plotly scatter plot grid visualization."""
+        if not self.cells:
+            return pd.DataFrame(columns=['x', 'y_plotly', 'Type', 'Color', 'Resistance', 'Info'])
+
+        cell_data = []
+        for coords, cell in self.cells.items():
+            # Plotly scatter typically has origin at bottom-left.
+            # Our grid (y, x) has origin top-left. Transform y for plotting.
+            plotly_y = self.grid_size - 1 - cell.y
+            info_str = f"Type: {cell.LABEL}<br>Pos: ({cell.x}, {cell.y})"
+            resistance = None
+            if isinstance(cell, CancerCell):
+                resistance = round(cell.resistance, 2)
+                info_str += f"<br>Resistance: {resistance}"
+            elif isinstance(cell, ImmuneCell):
+                 info_str += f"<br>Steps Alive: {cell.steps_alive}"
+                 if cell.is_activated:
+                      info_str += "<br>Status: Activated"
+
+
+            cell_data.append({
+                'x': cell.x,
+                'y_plotly': plotly_y,
+                'Type': cell.LABEL,
+                'Color': cell.COLOR,
+                'Resistance': resistance, # Store for potential coloring/hover later
+                'Info': info_str
+            })
+        return pd.DataFrame(cell_data)
+
+# --- Streamlit App ---
+
+st.set_page_config(layout="wide")
+st.title("Cancer Simulation: Tumor Growth, Immune Response & Drug Treatment")
+
+# --- Instructions ---
+st.markdown("""
+Welcome to the Cancer Simulation!
+*   Use the **sidebar** on the left to set the initial parameters for the simulation.
+*   Click **Start / Restart Simulation** to initialize the grid with the chosen parameters.
+*   **Run N Step(s):** Executes a fixed number of simulation steps.
+*   **Run Continuously:** Automatically runs the simulation step-by-step with a short delay (approx. 100ms) between steps. The grid and plots will update dynamically.
+*   **Stop:** Pauses the simulation (either manual steps or continuous run).
+*   The **Simulation Grid** visualizes the cells (Red=Cancer, Blue=Immune). Hover over cells for details.
+*   The **Plots** below the grid show population dynamics and average cancer cell resistance over time.
+""")
+st.divider()
+
+
+# --- Parameters Sidebar ---
+with st.sidebar:
+    st.header("Simulation Parameters")
+
+    st.subheader("Grid & General")
+    grid_size = st.slider("Grid Size (N x N)", 20, 100, 50, key="grid_size_slider")
+    max_steps = st.number_input("Max Simulation Steps", 50, 1000, 200, key="max_steps_input")
+
+    st.subheader("Initial Cells")
+    initial_cancer_cells = st.slider("Initial Cancer Cells", 1, max(1,grid_size*grid_size//4), 10, key="init_cancer_slider") # Limit initial cells
+    initial_immune_cells = st.slider("Initial Immune Cells", 0, max(1,grid_size*grid_size//2), 50, key="init_immune_slider")
+
+    st.subheader("Cancer Cell Properties")
+    cancer_growth_prob = st.slider("Growth Probability", 0.0, 1.0, 0.2, 0.01, key="cancer_growth_slider")
+    cancer_metastasis_prob = st.slider("Metastasis Probability", 0.0, 0.1, 0.005, 0.001, format="%.3f", key="cancer_meta_slider")
+    cancer_initial_resistance = st.slider("Initial Drug Resistance", 0.0, 1.0, 0.1, 0.01, key="cancer_res_slider")
+    cancer_mutation_rate = st.slider("Mutation Rate", 0.0, 0.1, 0.01, 0.001, format="%.3f", key="cancer_mut_slider")
+
+    st.subheader("Immune Cell Properties")
+    immune_base_kill_prob = st.slider("Base Kill Probability", 0.0, 1.0, 0.3, 0.01, key="immune_kill_slider")
+    immune_movement_prob = st.slider("Movement Probability", 0.0, 1.0, 0.8, 0.01, key="immune_move_slider")
+    immune_lifespan = st.number_input("Lifespan (steps)", 10, 500, 100, key="immune_life_input")
+
+    st.subheader("Drug Properties")
+    drug_effect_base = st.slider("Base Drug Effect (Kill Prob)", 0.0, 1.0, 0.4, 0.01, key="drug_effect_slider")
+    drug_resistance_interaction = st.slider("Resistance Interaction Factor", 0.0, 2.0, 1.0, 0.05, help="How much resistance reduces drug effect (1.0=linear)", key="drug_resint_slider")
+    drug_immune_activation_boost = st.slider("Immune Activation Boost", 0.0, 1.0, 0.3, 0.01, help="Added kill prob when activated", key="drug_immune_boost_slider")
+    drug_immune_boost_prob = st.slider("Immune Activation Probability", 0.0, 1.0, 0.7, 0.01, help="Prob. an immune cell near dying cancer gets activated", key="drug_immune_prob_slider")
+    drug_immune_activation_radius = st.slider("Immune Activation Radius", 0, 5, 1, help="Radius around dying cancer cell to activate immune cells", key="drug_immune_rad_slider")
+
+
+# Store parameters in a dictionary
+simulation_params = {
+    'grid_size': grid_size,
+    'max_steps': max_steps,
+    'initial_cancer_cells': initial_cancer_cells,
+    'initial_immune_cells': initial_immune_cells,
+    'cancer_growth_prob': cancer_growth_prob,
+    'cancer_metastasis_prob': cancer_metastasis_prob,
+    'cancer_initial_resistance': cancer_initial_resistance,
+    'cancer_mutation_rate': cancer_mutation_rate,
+    'immune_base_kill_prob': immune_base_kill_prob,
+    'immune_movement_prob': immune_movement_prob,
+    'immune_lifespan': immune_lifespan,
+    'drug_effect_base': drug_effect_base,
+    'drug_resistance_interaction': drug_resistance_interaction,
+    'drug_immune_activation_boost': drug_immune_activation_boost,
+    'drug_immune_boost_prob': drug_immune_boost_prob,
+    'drug_immune_activation_radius': drug_immune_activation_radius,
+}
+
+# --- Simulation Control and State ---
+
+# Initialize simulation state
+if 'simulation' not in st.session_state:
+    st.session_state.simulation = None
+    st.session_state.running = False # Overall simulation active (not paused/stopped)
+    st.session_state.continuously_running = False # Auto-step mode active
+    st.session_state.history_df = pd.DataFrame()
+    st.session_state.final_message = "" # To display end condition
+
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    if st.button("Start / Restart Simulation", key="start_button"):
+        st.session_state.simulation = Simulation(copy.deepcopy(simulation_params)) # Use deepcopy for params
+        st.session_state.running = True
+        st.session_state.continuously_running = False # Stop continuous if restarting
+        st.session_state.history_df = st.session_state.simulation.get_history_df()
+        st.session_state.final_message = ""
+        st.success("Simulation Initialized.")
+        st.rerun() # Rerun to update displays immediately
+
+with col2:
+    steps_to_run = st.number_input("Run Steps", min_value=1, max_value=max_steps, value=10, key="steps_input_manual")
+    run_button = st.button(f"Run {steps_to_run} Step(s)", disabled=(st.session_state.simulation is None or not st.session_state.running or st.session_state.continuously_running), key="run_steps_button")
+
+    if run_button:
+        sim = st.session_state.simulation
+        if sim:
+            progress_bar = st.progress(0)
+            steps_taken = 0
+            for i in range(steps_to_run):
+                if not st.session_state.running: break # Check if stopped externally
+                keep_running = sim.step()
+                steps_taken += 1
+                # Need to update history inside loop if we want live plot updates during manual steps, but simpler to update after
+                if not keep_running:
+                    st.session_state.running = False # Simulation ended naturally
+                    break
+                progress_bar.progress((i + 1) / steps_to_run)
+
+            progress_bar.empty()
+            st.session_state.history_df = sim.get_history_df() # Update history after batch run
+            st.info(f"Ran {steps_taken} steps. Current step: {sim.current_step}")
+            if not st.session_state.running and st.session_state.final_message:
+                 st.success(st.session_state.final_message) # Show end reason
+            st.rerun() # Update displays
+
+with col3:
+     run_cont_button = st.button("Run Continuously", disabled=(st.session_state.simulation is None or not st.session_state.running or st.session_state.continuously_running), key="run_cont_button")
+     if run_cont_button:
+         st.session_state.continuously_running = True
+         st.info("Running continuously...")
+         st.rerun() # Start the continuous loop
+
+with col4:
+     stop_button = st.button("Stop", disabled=(st.session_state.simulation is None or (not st.session_state.running) or (not st.session_state.continuously_running and not run_button) ), key="stop_button") # Enable if running or continuously running
+     if stop_button:
+         st.session_state.running = False # Stop the simulation process
+         st.session_state.continuously_running = False # Turn off continuous mode
+         st.warning("Simulation stopped by user.")
+         st.rerun()
+
+
+# --- Dynamic Update Logic for Continuous Run ---
+if st.session_state.get('simulation') and st.session_state.get('continuously_running') and st.session_state.get('running'):
+    sim = st.session_state.simulation
+    keep_running = sim.step()
+    st.session_state.history_df = sim.get_history_df() # Update history
+
+    if not keep_running:
+        st.session_state.running = False # Simulation ended naturally
+        st.session_state.continuously_running = False # Stop continuous mode
+        if st.session_state.final_message:
+            st.success(st.session_state.final_message) # Show end reason
+
+    # Schedule the next rerun with a delay
+    time.sleep(0.1) # 100 ms delay
+    st.rerun()
+
+# --- Visualization ---
+# Use placeholders to potentially update plots faster
+grid_placeholder = st.empty()
+charts_placeholder = st.container() # Use a container for the two charts
+
+if st.session_state.simulation:
+    sim = st.session_state.simulation
+
+    # --- Plotly Grid Visualization ---
+    with grid_placeholder.container(): # Draw in the placeholder
+        st.subheader(f"Simulation Grid (Step: {sim.current_step})")
+        df_grid = sim.get_plotly_grid_data()
+
+        fig_grid = go.Figure()
+
+        if not df_grid.empty:
+             # Add scatter trace for cells
+             fig_grid.add_trace(go.Scatter(
+                 x=df_grid['x'],
+                 y=df_grid['y_plotly'],
+                 mode='markers',
+                 marker=dict(
+                     color=df_grid['Color'],
+                     size=max(5, 400 / sim.grid_size), # Adjust marker size based on grid size
+                     symbol='square'
+                 ),
+                 text=df_grid['Info'], # Text appearing on hover
+                 hoverinfo='text',
+                 showlegend=False
+             ))
+
+        # Configure layout
+        fig_grid.update_layout(
+            xaxis=dict(
+                range=[-0.5, sim.grid_size - 0.5],
+                showgrid=True,
+                gridcolor='lightgrey',
+                zeroline=False,
+                showticklabels=False,
+                fixedrange=True # Prevent zoom/pan
+            ),
+            yaxis=dict(
+                range=[-0.5, sim.grid_size - 0.5],
+                showgrid=True,
+                gridcolor='lightgrey',
+                zeroline=False,
+                showticklabels=False,
+                scaleanchor="x", # Ensure square cells
+                scaleratio=1,
+                fixedrange=True # Prevent zoom/pan
+            ),
+            width=min(600, 800), # Adjust size as needed
+            height=min(600, 800),
+            margin=dict(l=10, r=10, t=40, b=10),
+            paper_bgcolor='white',
+            plot_bgcolor='white',
+            # Add manual legend items if needed, or rely on text/color
+             legend=dict(
+                itemsizing='constant',
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        # Add dummy traces for legend (if desired)
+        fig_grid.add_trace(go.Scatter(x=[None], y=[None], mode='markers', marker=dict(color=CancerCell.COLOR, size=10, symbol='square'), name='Cancer Cell'))
+        fig_grid.add_trace(go.Scatter(x=[None], y=[None], mode='markers', marker=dict(color=ImmuneCell.COLOR, size=10, symbol='square'), name='Immune Cell'))
+
+        st.plotly_chart(fig_grid, use_container_width=True) # Make it responsive
+
+
+    # --- Time Series Plots ---
+    with charts_placeholder: # Draw in the placeholder
+        st.divider()
+        col_chart1, col_chart2 = st.columns(2)
+
+        if not st.session_state.history_df.empty:
+            df_history = st.session_state.history_df
+
+            with col_chart1:
+                st.subheader("Cell Counts Over Time")
+                df_melt = df_history.melt(id_vars=['Step'],
+                                          value_vars=['Cancer Cells', 'Immune Cells'],
+                                          var_name='Cell Type', value_name='Count')
+
+                fig_line = px.line(df_melt, x='Step', y='Count', color='Cell Type',
+                                   title="Population Dynamics", markers=False, # Use markers=False for potentially smoother continuous updates
+                                   color_discrete_map={'Cancer Cells': CancerCell.COLOR, 'Immune Cells': ImmuneCell.COLOR})
+                fig_line.update_layout(legend_title_text='Cell Type')
+                st.plotly_chart(fig_line, use_container_width=True)
+
+            with col_chart2:
+                st.subheader("Average Cancer Cell Drug Resistance")
+                fig_res = px.line(df_history, x='Step', y='Average Resistance',
+                                  title="Average Resistance", markers=False) # Use markers=False
+                fig_res.update_yaxes(range=[0, 1.05]) # Resistance is between 0 and 1, add buffer
+                st.plotly_chart(fig_res, use_container_width=True)
+
+        elif st.session_state.simulation: # If sim exists but no history yet (step 0)
+             st.info("Run the simulation to see the plots.")
+
+
+else:
+    st.info("Click 'Start / Restart Simulation' to begin.")
+
+# Add some explanations at the bottom as well if desired
+# st.markdown(""" --- Explanation ... """)
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)

requirements.txt

@@ -0,0 +1,135 @@
+aiofiles==22.1.0
+aiosqlite==0.18.0
+altair==5.5.0
+anyio==3.6.2
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+arrow==1.2.3
+asttokens==2.2.1
+attrs==22.2.0
+Babel==2.12.1
+backcall==0.2.0
+beautifulsoup4==4.11.2
+bleach==6.0.0
+blinker==1.9.0
+brotlipy==0.7.0
+cachetools==5.5.2
+certifi==2021.10.8
+cffi @ file:///opt/conda/conda-bld/cffi_1642701102775/work
+charset-normalizer @ file:///tmp/build/80754af9/charset-normalizer_1630003229654/work
+click==8.1.8
+colorama @ file:///tmp/build/80754af9/colorama_1607707115595/work
+comm==0.1.2
+conda==4.12.0
+conda-content-trust @ file:///tmp/build/80754af9/conda-content-trust_1617045594566/work
+conda-package-handling @ file:///tmp/build/80754af9/conda-package-handling_1649105784853/work
+contourpy==1.3.0
+cryptography @ file:///tmp/build/80754af9/cryptography_1639414572950/work
+cycler==0.12.1
+debugpy==1.6.6
+decorator==5.1.1
+defusedxml==0.7.1
+executing==1.2.0
+fastjsonschema==2.16.3
+fonttools==4.56.0
+fqdn==1.5.1
+gitdb==4.0.12
+GitPython==3.1.44
+idna @ file:///tmp/build/80754af9/idna_1637925883363/work
+importlib-metadata==6.0.0
+importlib_resources==6.5.2
+ipykernel==6.21.3
+ipython==8.11.0
+ipython-genutils==0.2.0
+isoduration==20.11.0
+jedi==0.18.2
+Jinja2==3.1.2
+json5==0.9.11
+jsonpointer==2.3
+jsonschema==4.17.3
+jupyter-events==0.6.3
+jupyter-ydoc==0.2.2
+jupyter_client==8.0.3
+jupyter_core==5.2.0
+jupyter_server==2.4.0
+jupyter_server_fileid==0.8.0
+jupyter_server_terminals==0.4.4
+jupyter_server_ydoc==0.6.1
+jupyterlab==3.6.1
+jupyterlab-pygments==0.2.2
+jupyterlab_server==2.20.0
+kiwisolver==1.4.7
+MarkupSafe==2.1.2
+matplotlib==3.9.4
+matplotlib-inline==0.1.6
+mistune==2.0.5
+narwhals==1.32.0
+nbclassic==0.5.3
+nbclient==0.7.2
+nbconvert==7.2.9
+nbformat==5.7.3
+nest-asyncio==1.5.6
+notebook==6.5.3
+notebook_shim==0.2.2
+numpy==2.0.2
+packaging==23.0
+pandas==2.2.3
+pandocfilters==1.5.0
+parso==0.8.3
+pexpect==4.8.0
+pickleshare==0.7.5
+pillow==11.1.0
+platformdirs==3.1.0
+plotly==6.0.1
+prometheus-client==0.16.0
+prompt-toolkit==3.0.38
+protobuf==5.29.4
+psutil==5.9.4
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==19.0.1
+pycosat==0.6.3
+pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work
+pydeck==0.9.1
+Pygments==2.14.0
+pyOpenSSL @ file:///opt/conda/conda-bld/pyopenssl_1643788558760/work
+pyparsing==3.2.3
+pyrsistent==0.19.3
+PySocks @ file:///tmp/build/80754af9/pysocks_1605305812635/work
+python-dateutil==2.8.2
+python-json-logger==2.0.7
+pytz==2025.2
+PyYAML==6.0
+pyzmq==25.0.0
+requests==2.28.2
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+ruamel-yaml-conda @ file:///tmp/build/80754af9/ruamel_yaml_1616016711199/work
+Send2Trash==1.8.0
+six @ file:///tmp/build/80754af9/six_1644875935023/work
+smmap==5.0.2
+sniffio==1.3.0
+soupsieve==2.4
+stack-data==0.6.2
+streamlit==1.44.0
+tenacity==9.0.0
+terminado==0.17.1
+tinycss2==1.2.1
+toml==0.10.2
+tomli==2.0.1
+tornado==6.2
+tqdm @ file:///opt/conda/conda-bld/tqdm_1647339053476/work
+traitlets==5.9.0
+typing_extensions==4.13.0
+tzdata==2025.2
+uri-template==1.2.0
+urllib3 @ file:///opt/conda/conda-bld/urllib3_1643638302206/work
+uv==0.6.10
+watchdog==6.0.0
+wcwidth==0.2.6
+webcolors==1.12
+webencodings==0.5.1
+websocket-client==1.5.1
+y-py==0.5.9
+ypy-websocket==0.8.2
+zipp==3.15.0