Moving examples to use the new discrete spaces (#198)

Author: quaquel

examples/advanced/epstein_civil_violence/epstein_civil_violence/agent.py

@@ -3,13 +3,23 @@
 import mesa
 
 
-class Citizen(mesa.Agent):
+class EpsteinAgent(mesa.experimental.cell_space.CellAgent):
+    def update_neighbors(self):
+        """
+        Look around and see who my neighbors are
+        """
+        self.neighborhood = self.cell.get_neighborhood(radius=self.vision)
+
+        self.neighbors = self.neighborhood.agents
+        self.empty_neighbors = [c for c in self.neighborhood if c.is_empty]
+
+
+class Citizen(EpsteinAgent):
     """
     A member of the general population, may or may not be in active rebellion.
     Summary of rule: If grievance - risk > threshold, rebel.
 
     Attributes:
-        x, y: Grid coordinates
         hardship: Agent's 'perceived hardship (i.e., physical or economic
             privation).' Exogenous, drawn from U(0,1).
         regime_legitimacy: Agent's perception of regime legitimacy, equal
@@ -30,7 +40,6 @@ class Citizen(mesa.Agent):
     def __init__(
         self,
         model,
-        pos,
         hardship,
         regime_legitimacy,
         risk_aversion,
@@ -40,7 +49,7 @@ def __init__(
         """
         Create a new Citizen.
         Args:
-            x, y: Grid coordinates
+            model: the model to which the agent belongs
             hardship: Agent's 'perceived hardship (i.e., physical or economic
                 privation).' Exogenous, drawn from U(0,1).
             regime_legitimacy: Agent's perception of regime legitimacy, equal
@@ -53,8 +62,6 @@ def __init__(
             model: model instance
         """
         super().__init__(model)
-        self.breed = "citizen"
-        self.pos = pos
         self.hardship = hardship
         self.regime_legitimacy = regime_legitimacy
         self.risk_aversion = risk_aversion
@@ -79,32 +86,21 @@ def step(self):
             self.condition = "Active"
         else:
             self.condition = "Quiescent"
-        if self.model.movement and self.empty_neighbors:
-            new_pos = self.random.choice(self.empty_neighbors)
-            self.model.grid.move_agent(self, new_pos)
 
-    def update_neighbors(self):
-        """
-        Look around and see who my neighbors are
-        """
-        self.neighborhood = self.model.grid.get_neighborhood(
-            self.pos, moore=True, radius=self.vision
-        )
-        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
-        self.empty_neighbors = [
-            c for c in self.neighborhood if self.model.grid.is_cell_empty(c)
-        ]
+        if self.model.movement and self.empty_neighbors:
+            new_cell = self.random.choice(self.empty_neighbors)
+            self.move_to(new_cell)
 
     def update_estimated_arrest_probability(self):
         """
         Based on the ratio of cops to actives in my neighborhood, estimate the
         p(Arrest | I go active).
         """
-        cops_in_vision = len([c for c in self.neighbors if c.breed == "cop"])
+        cops_in_vision = len([c for c in self.neighbors if isinstance(c, Cop)])
         actives_in_vision = 1.0  # citizen counts herself
         for c in self.neighbors:
             if (
-                c.breed == "citizen"
+                isinstance(c, Citizen)
                 and c.condition == "Active"
                 and c.jail_sentence == 0
             ):
@@ -114,7 +110,7 @@ def update_estimated_arrest_probability(self):
         )
 
 
-class Cop(mesa.Agent):
+class Cop(EpsteinAgent):
     """
     A cop for life.  No defection.
     Summary of rule: Inspect local vision and arrest a random active agent.
@@ -126,7 +122,7 @@ class Cop(mesa.Agent):
             able to inspect
     """
 
-    def __init__(self, model, pos, vision):
+    def __init__(self, model, vision):
         """
         Create a new Cop.
         Args:
@@ -136,8 +132,6 @@ def __init__(self, model, pos, vision):
             model: model instance
         """
         super().__init__(model)
-        self.breed = "cop"
-        self.pos = pos
         self.vision = vision
 
     def step(self):
@@ -149,7 +143,7 @@ def step(self):
         active_neighbors = []
         for agent in self.neighbors:
             if (
-                agent.breed == "citizen"
+                isinstance(agent, Citizen)
                 and agent.condition == "Active"
                 and agent.jail_sentence == 0
             ):
@@ -161,16 +155,4 @@ def step(self):
             arrestee.condition = "Quiescent"
         if self.model.movement and self.empty_neighbors:
             new_pos = self.random.choice(self.empty_neighbors)
-            self.model.grid.move_agent(self, new_pos)
-
-    def update_neighbors(self):
-        """
-        Look around and see who my neighbors are.
-        """
-        self.neighborhood = self.model.grid.get_neighborhood(
-            self.pos, moore=True, radius=self.vision
-        )
-        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
-        self.empty_neighbors = [
-            c for c in self.neighborhood if self.model.grid.is_cell_empty(c)
-        ]
+            self.move_to(new_pos)

examples/advanced/epstein_civil_violence/epstein_civil_violence/model.py

@@ -59,7 +59,9 @@ def __init__(
         self.max_iters = max_iters
         self.iteration = 0
 
-        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+        self.grid = mesa.experimental.cell_space.OrthogonalMooreGrid(
+            (width, height), capacity=1, torus=True
+        )
 
         model_reporters = {
             "Quiescent": lambda m: self.count_type_citizens(m, "Quiescent"),
@@ -68,9 +70,9 @@ def __init__(
             "Cops": self.count_cops,
         }
         agent_reporters = {
-            "x": lambda a: a.pos[0],
-            "y": lambda a: a.pos[1],
-            "breed": lambda a: a.breed,
+            "x": lambda a: a.cell.coordinate[0],
+            "y": lambda a: a.cell.coordinate[1],
+            "breed": lambda a: type(a).__name__,
             "jail_sentence": lambda a: getattr(a, "jail_sentence", None),
             "condition": lambda a: getattr(a, "condition", None),
             "arrest_probability": lambda a: getattr(a, "arrest_probability", None),
@@ -81,22 +83,21 @@ def __init__(
         if self.cop_density + self.citizen_density > 1:
             raise ValueError("Cop density + citizen density must be less than 1")
 
-        for contents, (x, y) in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < self.cop_density:
-                cop = Cop(self, (x, y), vision=self.cop_vision)
-                self.grid[x][y] = cop
+                cop = Cop(self, vision=self.cop_vision)
+                cop.move_to(cell)
 
             elif self.random.random() < (self.cop_density + self.citizen_density):
                 citizen = Citizen(
                     self,
-                    (x, y),
                     hardship=self.random.random(),
                     regime_legitimacy=self.legitimacy,
                     risk_aversion=self.random.random(),
                     threshold=self.active_threshold,
                     vision=self.citizen_vision,
                 )
-                self.grid[x][y] = citizen
+                citizen.move_to(cell)
 
         self.running = True
         self.datacollector.collect(self)
@@ -117,34 +118,29 @@ def count_type_citizens(model, condition, exclude_jailed=True):
         """
         Helper method to count agents by Quiescent/Active.
         """
-        count = 0
-        for agent in model.agents:
-            if agent.breed == "cop":
-                continue
-            if exclude_jailed and agent.jail_sentence > 0:
-                continue
-            if agent.condition == condition:
-                count += 1
-        return count
+        citizens = model.agents_by_type[Citizen]
+
+        if exclude_jailed:
+            return len(
+                [
+                    c
+                    for c in citizens
+                    if (c.condition == condition) and (c.jail_sentence == 0)
+                ]
+            )
+        else:
+            return len([c for c in citizens if c.condition == condition])
 
     @staticmethod
     def count_jailed(model):
         """
         Helper method to count jailed agents.
         """
-        count = 0
-        for agent in model.agents:
-            if agent.breed == "citizen" and agent.jail_sentence > 0:
-                count += 1
-        return count
+        return len([a for a in model.agents_by_type[Citizen] if a.jail_sentence > 0])
 
     @staticmethod
     def count_cops(model):
         """
         Helper method to count jailed agents.
         """
-        count = 0
-        for agent in model.agents:
-            if agent.breed == "cop":
-                count += 1
-        return count
+        return len(model.agents_by_type[Cop])

examples/advanced/pd_grid/pd_grid/agent.py

@@ -1,7 +1,7 @@
-import mesa
+from mesa.experimental.cell_space import CellAgent
 
 
-class PDAgent(mesa.Agent):
+class PDAgent(CellAgent):
     """Agent member of the iterated, spatial prisoner's dilemma model."""
 
     def __init__(self, model, starting_move=None):
@@ -22,14 +22,15 @@ def __init__(self, model, starting_move=None):
         self.next_move = None
 
     @property
-    def isCooroperating(self):
+    def is_cooroperating(self):
         return self.move == "C"
 
     def step(self):
         """Get the best neighbor's move, and change own move accordingly
         if better than own score."""
 
-        neighbors = self.model.grid.get_neighbors(self.pos, True, include_center=True)
+        # neighbors = self.model.grid.get_neighbors(self.pos, True, include_center=True)
+        neighbors = [*list(self.cell.neighborhood.agents), self]
         best_neighbor = max(neighbors, key=lambda a: a.score)
         self.next_move = best_neighbor.move
 
@@ -41,7 +42,7 @@ def advance(self):
         self.score += self.increment_score()
 
     def increment_score(self):
-        neighbors = self.model.grid.get_neighbors(self.pos, True)
+        neighbors = self.cell.neighborhood.agents
         if self.model.activation_order == "Simultaneous":
             moves = [neighbor.next_move for neighbor in neighbors]
         else:

examples/advanced/pd_grid/pd_grid/model.py

@@ -1,4 +1,5 @@
 import mesa
+from mesa.experimental.cell_space import OrthogonalMooreGrid
 
 from .agent import PDAgent
 
@@ -25,15 +26,18 @@ def __init__(
                            Determines the agent activation regime.
             payoffs: (optional) Dictionary of (move, neighbor_move) payoffs.
         """
-        super().__init__()
+        super().__init__(seed=seed)
         self.activation_order = activation_order
-        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), torus=True)
+
+        if payoffs is not None:
+            self.payoff = payoffs
 
         # Create agents
         for x in range(width):
             for y in range(height):
                 agent = PDAgent(self)
-                self.grid.place_agent(agent, (x, y))
+                agent.cell = self.grid[(x, y)]
 
         self.datacollector = mesa.DataCollector(
             {

examples/advanced/sugarscape_g1mt/sugarscape_g1mt/model.py

@@ -2,6 +2,7 @@
 
 import mesa
 import numpy as np
+from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
 
 from .resource_agents import Resource
 from .trader_agents import Trader
@@ -69,7 +70,7 @@ def __init__(
         self.running = True
 
         # initiate mesa grid class
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)
+        self.grid = OrthogonalVonNeumannGrid((self.width, self.height), torus=False)
         # initiate datacollector
         self.datacollector = mesa.DataCollector(
             model_reporters={
@@ -88,11 +89,10 @@ def __init__(
         sugar_distribution = np.genfromtxt(Path(__file__).parent / "sugar-map.txt")
         spice_distribution = np.flip(sugar_distribution, 1)
 
-        for _, (x, y) in self.grid.coord_iter():
-            max_sugar = sugar_distribution[x, y]
-            max_spice = spice_distribution[x, y]
-            resource = Resource(self, max_sugar, max_spice)
-            self.grid.place_agent(resource, (x, y))
+        for cell in self.grid.all_cells:
+            max_sugar = sugar_distribution[cell.coordinate]
+            max_spice = spice_distribution[cell.coordinate]
+            Resource(self, max_sugar, max_spice, cell)
 
         for _ in range(self.initial_population):
             # get agent position
@@ -111,18 +111,18 @@ def __init__(
             )
             # give agents vision
             vision = int(self.random.uniform(self.vision_min, self.vision_max + 1))
+
+            cell = self.grid[(x, y)]
             # create Trader object
-            trader = Trader(
+            Trader(
                 self,
-                moore=False,
+                cell,
                 sugar=sugar,
                 spice=spice,
                 metabolism_sugar=metabolism_sugar,
                 metabolism_spice=metabolism_spice,
                 vision=vision,
             )
-            # place agent
-            self.grid.place_agent(trader, (x, y))
 
     def step(self):
         """

examples/advanced/sugarscape_g1mt/sugarscape_g1mt/resource_agents.py

@@ -1,20 +1,21 @@
-import mesa
+from mesa.experimental.cell_space import FixedAgent
 
 
-class Resource(mesa.Agent):
+class Resource(FixedAgent):
     """
     Resource:
     - contains an amount of sugar and spice
     - grows 1 amount of sugar at each turn
     - grows 1 amount of spice at each turn
     """
 
-    def __init__(self, model, max_sugar, max_spice):
+    def __init__(self, model, max_sugar, max_spice, cell):
         super().__init__(model)
         self.sugar_amount = max_sugar
         self.max_sugar = max_sugar
         self.spice_amount = max_spice
         self.max_spice = max_spice
+        self.cell = cell
 
     def step(self):
         """