a few more examples are moved over

Author: quaquel

examples/hotelling_law/hotelling_law/model.py

@@ -140,7 +140,7 @@ def get_store_price_lambda(unique_id):
         """Return a lambda function that gets the
         price of a store by its unique ID."""
         return lambda m: next(
-            (agent.price for agent in m.store_agents if agent.unique_id == unique_id), 0
+            (agent.price for agent in m.agents_by_type[StoreAgent] if agent.unique_id == unique_id), 0
         )
 
     @staticmethod
@@ -150,7 +150,7 @@ def get_market_share_lambda(unique_id):
         return lambda m: next(
             (
                 agent.market_share
-                for agent in m.store_agents
+                for agent in m.agents_by_type[StoreAgent]
                 if agent.unique_id == unique_id
             ),
             0,
@@ -163,7 +163,7 @@ def get_revenue_lambda(unique_id):
         return lambda m: next(
             (
                 agent.market_share * agent.price
-                for agent in m.store_agents
+                for agent in m.agents_by_type[StoreAgent]
                 if agent.unique_id == unique_id
             ),
             0,
@@ -211,10 +211,10 @@ def step(self):
 
     def recalculate_market_share(self):
         # Reset market share for all stores directly
-        for store in self.store_agents:
+        for store in  self.agents_by_type[StoreAgent]:
             store.market_share = 0
 
-        for consumer in self.consumer_agents:
+        for consumer in  self.agents_by_type[ConsumerAgent]:
             preferred_store = consumer.determine_preferred_store()
             if preferred_store:
                 preferred_store.market_share += 1
@@ -238,16 +238,16 @@ def export_data(self):
     def compute_average_price(self):
         if len(self.store_agents) == 0:
             return 0
-        return np.mean([agent.price for agent in self.store_agents])
+        return np.mean([agent.price for agent in  self.agents_by_type[StoreAgent]])
 
     # Function to compute the average market share for all store agents,
     def compute_average_market_share(self):
         if not self.store_agents:
             return 0
 
-        total_consumers = sum(agent.market_share for agent in self.store_agents)
-        average_market_share = total_consumers / len(self.store_agents)
+        total_consumers = sum(agent.market_share for agent in  self.agents_by_type[StoreAgent])
+        average_market_share = total_consumers / len( self.agents_by_type[StoreAgent])
         return average_market_share
 
     def compute_price_variance(self):
-        return np.var([agent.price for agent in self.store_agents])
+        return np.var([agent.price for agent in self.agents_by_type[StoreAgent]])

examples/pd_grid/pd_grid/agent.py

@@ -1,7 +1,8 @@
 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 +23,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 +43,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/pd_grid/pd_grid/model.py

@@ -1,8 +1,8 @@
 import mesa
+from mesa.experimental.cell_space import OrthogonalMooreGrid
 
 from .agent import PDAgent
 
-
 class PdGrid(mesa.Model):
     """Model class for iterated, spatial prisoner's dilemma model."""
 
@@ -25,15 +25,19 @@ 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 = 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/schelling/model.py

@@ -1,7 +1,8 @@
 import mesa
+from mesa.experimental.cell_space import CellAgent, OrthogonalMooreGrid
 
 
-class SchellingAgent(mesa.Agent):
+class SchellingAgent(CellAgent):
     """
     Schelling segregation agent
     """
@@ -19,15 +20,13 @@ def __init__(self, model, agent_type):
 
     def step(self):
         similar = 0
-        for neighbor in self.model.grid.iter_neighbors(
-            self.pos, moore=True, radius=self.model.radius
-        ):
+        for neighbor in self.cell.get_neighborhood(radius=self.model.radius).agents:
             if neighbor.type == self.type:
                 similar += 1
 
         # If unhappy, move:
         if similar < self.model.homophily:
-            self.model.grid.move_to_empty(self)
+            self.cell = self.model.grid.select_random_empty_cell()
         else:
             self.model.happy += 1
 
@@ -67,7 +66,7 @@ def __init__(
         self.homophily = homophily
         self.radius = radius
 
-        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), torus=True)
 
         self.happy = 0
         self.datacollector = mesa.DataCollector(
@@ -78,11 +77,11 @@ def __init__(
         # We use a grid iterator that returns
         # the coordinates of a cell as well as
         # its contents. (coord_iter)
-        for _, pos in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < self.density:
                 agent_type = 1 if self.random.random() < self.minority_pc else 0
                 agent = SchellingAgent(self, agent_type)
-                self.grid.place_agent(agent, pos)
+                agent.cell = cell
 
         self.datacollector.collect(self)
 

examples/schelling_experimental/model.py

@@ -1,7 +1,8 @@
 import mesa
 
+from mesa.experimental.cell_space import CellAgent, OrthogonalMooreGrid
 
-class SchellingAgent(mesa.Agent):
+class SchellingAgent(CellAgent):
     """
     Schelling segregation agent
     """
@@ -18,13 +19,13 @@ def __init__(self, model, agent_type):
 
     def step(self):
         similar = 0
-        for neighbor in self.model.grid.iter_neighbors(self.pos, True):
+        for neighbor in self.cell.neighborhood.agents:
             if neighbor.type == self.type:
                 similar += 1
 
         # If unhappy, move:
         if similar < self.model.homophily:
-            self.model.grid.move_to_empty(self)
+            self.cell = self.model.grid.select_random_empty_cell()
         else:
             self.model.happy += 1
 
@@ -40,7 +41,7 @@ def __init__(self, width=20, height=20, density=0.8, minority_pc=0.2, homophily=
         self.height = height
         self.homophily = homophily
 
-        self.grid = mesa.space.SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), torus=True)
 
         self.happy = 0
         self.datacollector = mesa.DataCollector(
@@ -51,11 +52,11 @@ def __init__(self, width=20, height=20, density=0.8, minority_pc=0.2, homophily=
         # We use a grid iterator that returns
         # the coordinates of a cell as well as
         # its contents. (coord_iter)
-        for _, pos in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < density:
                 agent_type = 1 if self.random.random() < minority_pc else 0
                 agent = SchellingAgent(self, agent_type)
-                self.grid.place_agent(agent, pos)
+                agent.cell = cell
 
         self.datacollector.collect(self)
 

examples/shape_example/shape_example/model.py

@@ -1,6 +1,8 @@
 import mesa
 
 
+from mesa.experimental.cell_space import OrthogonalMooreGrid
+
 class Walker(mesa.Agent):
     def __init__(self, model, heading=(1, 0)):
         super().__init__(model)
@@ -13,27 +15,21 @@ def __init__(self, N=2, width=20, height=10):
         super().__init__()
         self.N = N  # num of agents
         self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1))  # tuples are fast
-        self.grid = mesa.space.SingleGrid(width, height, torus=False)
+        self.grid = OrthogonalMooreGrid((width, height), torus=True)
 
         self.make_walker_agents()
         self.running = True
 
     def make_walker_agents(self):
-        unique_id = 0
-        while True:
-            if unique_id == self.N:
-                break
-            x = self.random.randrange(self.grid.width)
-            y = self.random.randrange(self.grid.height)
-            pos = (x, y)
+        for _ in range(self.N):
+            x = self.random.randrange(self.grid.dimensions[0])
+            y = self.random.randrange(self.grid.dimensions[1])
+            cell = self.grid[(x, y)]
             heading = self.random.choice(self.headings)
             # heading = (1, 0)
-            if self.grid.is_cell_empty(pos):
-                print(f"Creating agent {unique_id} at ({x}, {y})")
+            if cell.is_empty:
                 a = Walker(self, heading)
-
-                self.grid.place_agent(a, pos)
-                unique_id += 1
+                a.cell = cell
 
     def step(self):
         self.agents.shuffle_do("step")