Revert basic example models to current grids

Revert the basic models back to the current stable grids

Author: EwoutH

examples/boltzmann_wealth_model/model.py

@@ -20,21 +20,19 @@ class BoltzmannWealthModel(mesa.Model):
     def __init__(self, N=100, width=10, height=10):
         super().__init__()
         self.num_agents = N
-        self.grid = mesa.experimental.cell_space.OrthogonalMooreGrid(
-            (width, height), torus=True, random=self.random
-        )
+        self.grid = mesa.space.MultiGrid(width, height, True)
 
         self.datacollector = mesa.DataCollector(
             model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": "wealth"}
         )
         # Create agents
         for _ in range(self.num_agents):
-            agent = MoneyAgent(self)
+            a = MoneyAgent(self)
 
             # Add the agent to a random grid cell
-            x = self.random.randrange(width)
-            y = self.random.randrange(height)
-            agent.move_to(self.grid[(x, y)])
+            x = self.random.randrange(self.grid.width)
+            y = self.random.randrange(self.grid.height)
+            self.grid.place_agent(a, (x, y))
 
         self.running = True
         self.datacollector.collect(self)
@@ -49,23 +47,31 @@ def run_model(self, n):
             self.step()
 
 
-class MoneyAgent(mesa.experimental.cell_space.CellAgent):
+class MoneyAgent(mesa.Agent):
     """An agent with fixed initial wealth."""
 
     def __init__(self, model):
         super().__init__(model)
         self.wealth = 1
 
+    def move(self):
+        possible_steps = self.model.grid.get_neighborhood(
+            self.pos, moore=True, include_center=False
+        )
+        new_position = self.random.choice(possible_steps)
+        self.model.grid.move_agent(self, new_position)
+
     def give_money(self):
-        cellmates = [
-            agent for agent in self.cell.agents if agent is not self
-        ]  # Ensure agent is not giving money to itself
+        cellmates = self.model.grid.get_cell_list_contents([self.pos])
+        cellmates.pop(
+            cellmates.index(self)
+        )  # Ensure agent is not giving money to itself
         if len(cellmates) > 0:
             other = self.random.choice(cellmates)
             other.wealth += 1
             self.wealth -= 1
 
     def step(self):
-        self.cell = self.cell.neighborhood.select_random_cell()
+        self.move()
         if self.wealth > 0:
             self.give_money()

examples/conways_game_of_life/conways_game_of_life/cell.py

@@ -1,27 +1,28 @@
-from mesa.experimental.cell_space import CellAgent
+import mesa
 
 
-class Cell(CellAgent):
+class Cell(mesa.Agent):
     """Represents a single ALIVE or DEAD cell in the simulation."""
 
     DEAD = 0
     ALIVE = 1
 
-    def __init__(self, model, init_state=DEAD):
+    def __init__(self, pos, model, init_state=DEAD):
         """
         Create a cell, in the given state, at the given x, y position.
         """
         super().__init__(model)
+        self.x, self.y = pos
         self.state = init_state
-        self._next_state = None
+        self._nextState = None
 
     @property
-    def is_alive(self):
+    def isAlive(self):
         return self.state == self.ALIVE
 
     @property
     def neighbors(self):
-        return self.cell.neighborhood.agents
+        return self.model.grid.iter_neighbors((self.x, self.y), True)
 
     def determine_state(self):
         """
@@ -34,19 +35,19 @@ def determine_state(self):
 
         # Get the neighbors and apply the rules on whether to be alive or dead
         # at the next tick.
-        live_neighbors = sum(neighbor.is_alive for neighbor in self.neighbors)
+        live_neighbors = sum(neighbor.isAlive for neighbor in self.neighbors)
 
         # Assume nextState is unchanged, unless changed below.
-        self._next_state = self.state
-        if self.is_alive:
+        self._nextState = self.state
+        if self.isAlive:
             if live_neighbors < 2 or live_neighbors > 3:
-                self._next_state = self.DEAD
+                self._nextState = self.DEAD
         else:
             if live_neighbors == 3:
-                self._next_state = self.ALIVE
+                self._nextState = self.ALIVE
 
     def assume_state(self):
         """
         Set the state to the new computed state -- computed in step().
         """
-        self.state = self._next_state
+        self.state = self._nextState

examples/conways_game_of_life/conways_game_of_life/model.py

@@ -15,17 +15,15 @@ def __init__(self, width=50, height=50):
         """
         super().__init__()
         # Use a simple grid, where edges wrap around.
-        self.grid = mesa.experimental.cell_space.OrthogonalMooreGrid(
-            (width, height), torus=True
-        )
+        self.grid = mesa.space.SingleGrid(width, height, torus=True)
 
         # Place a cell at each location, with some initialized to
         # ALIVE and some to DEAD.
-        for cell in self.grid.all_cells:
-            cell_agent = Cell(self)
+        for contents, (x, y) in self.grid.coord_iter():
+            cell = Cell((x, y), self)
             if self.random.random() < 0.1:
-                cell_agent.state = cell_agent.ALIVE
-            cell_agent.move_to(cell)
+                cell.state = cell.ALIVE
+            self.grid.place_agent(cell, (x, y))
 
         self.running = True
 

examples/schelling/model.py

@@ -1,8 +1,7 @@
 import mesa
-from mesa.experimental.cell_space import CellAgent, OrthogonalMooreGrid
 
 
-class SchellingAgent(CellAgent):
+class SchellingAgent(mesa.Agent):
     """
     Schelling segregation agent
     """
@@ -17,15 +16,15 @@ def __init__(self, model: mesa.Model, agent_type: int) -> None:
         super().__init__(model)
         self.type = agent_type
 
-    def step(self):
-        neighbors = self.cell.get_neighborhood(radius=self.model.radius).agents
-        similar = len(
-            [neighbor for neighbor in neighbors if neighbor.type == self.type]
+    def step(self) -> None:
+        neighbors = self.model.grid.iter_neighbors(
+            self.pos, moore=True, radius=self.model.radius
         )
+        similar = sum(1 for neighbor in neighbors if neighbor.type == self.type)
 
         # If unhappy, move:
         if similar < self.model.homophily:
-            self.cell = self.model.grid.select_random_empty_cell()
+            self.model.grid.move_to_empty(self)
         else:
             self.model.happy += 1
 
@@ -61,7 +60,7 @@ def __init__(
         self.homophily = homophily
         self.radius = radius
 
-        self.grid = OrthogonalMooreGrid((width, height), torus=True)
+        self.grid = mesa.space.SingleGrid(width, height, torus=True)
 
         self.happy = 0
         self.datacollector = mesa.DataCollector(
@@ -72,11 +71,11 @@ def __init__(
         # We use a grid iterator that returns
         # the coordinates of a cell as well as
         # its contents. (coord_iter)
-        for cell in self.grid.all_cells:
+        for _, pos in self.grid.coord_iter():
             if self.random.random() < density:
                 agent_type = 1 if self.random.random() < minority_pc else 0
                 agent = SchellingAgent(self, agent_type)
-                agent.cell = cell
+                self.grid.place_agent(agent, pos)
 
         self.datacollector.collect(self)
 

examples/virus_on_network/virus_on_network/model.py

@@ -3,7 +3,6 @@
 
 import mesa
 import networkx as nx
-from mesa.experimental.cell_space import FixedAgent, Network
 
 
 class State(Enum):
@@ -13,7 +12,7 @@ class State(Enum):
 
 
 def number_state(model, state):
-    return sum(1 for a in model.agents if a.state is state)
+    return sum(1 for a in model.grid.get_all_cell_contents() if a.state is state)
 
 
 def number_infected(model):
@@ -47,7 +46,7 @@ def __init__(
         self.num_nodes = num_nodes
         prob = avg_node_degree / self.num_nodes
         self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob)
-        self.grid = Network(self.G)
+        self.grid = mesa.space.NetworkGrid(self.G)
 
         self.initial_outbreak_size = (
             initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes
@@ -77,13 +76,12 @@ def __init__(
             )
 
             # Add the agent to the node
-            a.cell = self.grid[node]
+            self.grid.place_agent(a, node)
 
         # Infect some nodes
         infected_nodes = self.random.sample(list(self.G), self.initial_outbreak_size)
-        for node in infected_nodes:
-            for agent in self.grid[node].agents:
-                agent.state = State.INFECTED
+        for a in self.grid.get_cell_list_contents(infected_nodes):
+            a.state = State.INFECTED
 
         self.running = True
         self.datacollector.collect(self)
@@ -106,7 +104,7 @@ def run_model(self, n):
             self.step()
 
 
-class VirusAgent(FixedAgent):
+class VirusAgent(mesa.Agent):
     """
     Individual Agent definition and its properties/interaction methods
     """
@@ -130,10 +128,12 @@ def __init__(
         self.gain_resistance_chance = gain_resistance_chance
 
     def try_to_infect_neighbors(self):
-        neighbors_nodes = self.cell.neighborhood
+        neighbors_nodes = self.model.grid.get_neighborhood(
+            self.pos, include_center=False
+        )
         susceptible_neighbors = [
             agent
-            for agent in neighbors_nodes.agents
+            for agent in self.model.grid.get_cell_list_contents(neighbors_nodes)
             if agent.state is State.SUSCEPTIBLE
         ]
         for a in susceptible_neighbors: