sugarscape

Author: quaquel

examples/sugarscape_cg/sugarscape_cg/agents.py

@@ -2,79 +2,76 @@
 
 import mesa
 
+from mesa.experimental.cell_space import FixedAgent, CellAgent
 
-def get_distance(pos_1, pos_2):
+def get_distance(cell_1, cell_2):
     """Get the distance between two point
 
     Args:
         pos_1, pos_2: Coordinate tuples for both points.
     """
-    x1, y1 = pos_1
-    x2, y2 = pos_2
+    x1, y1 = cell_1.coordinate
+    x2, y2 = cell_2.coordinate
     dx = x1 - x2
     dy = y1 - y2
     return math.sqrt(dx**2 + dy**2)
 
 
-class SsAgent(mesa.Agent):
-    def __init__(self, model, moore=False, sugar=0, metabolism=0, vision=0):
+class SsAgent(CellAgent):
+    def __init__(self, model, cell, sugar=0, metabolism=0, vision=0):
         super().__init__(model)
-        self.moore = moore
+        self.cell = cell
         self.sugar = sugar
         self.metabolism = metabolism
         self.vision = vision
 
-    def get_sugar(self, pos):
-        this_cell = self.model.grid.get_cell_list_contents([pos])
-        for agent in this_cell:
-            if type(agent) is Sugar:
+    def get_sugar(self, cell):
+        for agent in cell.agents:
+            if isinstance(agent, Sugar):
                 return agent
 
-    def is_occupied(self, pos):
-        this_cell = self.model.grid.get_cell_list_contents([pos])
-        return any(isinstance(agent, SsAgent) for agent in this_cell)
+    def is_occupied(self, cell):
+        return any(isinstance(agent, SsAgent) for agent in cell.agents)
 
     def move(self):
         # Get neighborhood within vision
         neighbors = [
-            i
-            for i in self.model.grid.get_neighborhood(
-                self.pos, self.moore, False, radius=self.vision
-            )
-            if not self.is_occupied(i)
+            cell
+            for cell in self.cell.get_neighborhood(radius=self.vision)
+            if not self.is_occupied(cell)
         ]
-        neighbors.append(self.pos)
+        neighbors.append(self.cell)
         # Look for location with the most sugar
-        max_sugar = max(self.get_sugar(pos).amount for pos in neighbors)
+        max_sugar = max(self.get_sugar(cell).amount for cell in neighbors)
         candidates = [
-            pos for pos in neighbors if self.get_sugar(pos).amount == max_sugar
+            cell for cell in neighbors if self.get_sugar(cell).amount == max_sugar
         ]
         # Narrow down to the nearest ones
-        min_dist = min(get_distance(self.pos, pos) for pos in candidates)
+        min_dist = min(get_distance(self.cell, cell) for cell in candidates)
         final_candidates = [
-            pos for pos in candidates if get_distance(self.pos, pos) == min_dist
+            cell for cell in candidates if get_distance(self.cell, cell) == min_dist
         ]
         self.random.shuffle(final_candidates)
-        self.model.grid.move_agent(self, final_candidates[0])
+        self.cell = final_candidates[0]
 
     def eat(self):
-        sugar_patch = self.get_sugar(self.pos)
+        sugar_patch = self.get_sugar(self.cell)
         self.sugar = self.sugar - self.metabolism + sugar_patch.amount
         sugar_patch.amount = 0
 
     def step(self):
         self.move()
         self.eat()
         if self.sugar <= 0:
-            self.model.grid.remove_agent(self)
             self.remove()
 
 
-class Sugar(mesa.Agent):
-    def __init__(self, model, max_sugar):
+class Sugar(FixedAgent):
+    def __init__(self, model, max_sugar, cell):
         super().__init__(model)
         self.amount = max_sugar
         self.max_sugar = max_sugar
+        self.cell = cell
 
     def step(self):
         self.amount = min([self.max_sugar, self.amount + 1])

examples/sugarscape_cg/sugarscape_cg/model.py

@@ -12,6 +12,7 @@
 from pathlib import Path
 
 import mesa
+from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
 
 from .agents import SsAgent, Sugar
 
@@ -23,21 +24,26 @@ class SugarscapeCg(mesa.Model):
 
     verbose = True  # Print-monitoring
 
-    def __init__(self, width=50, height=50, initial_population=100):
+    def __init__(self, width=50, height=50, initial_population=100, seed=None):
         """
-        Create a new Constant Growback model with the given parameters.
+        Create a new constant grow back model with the given parameters.
 
         Args:
+            width (int): Width of the Sugarscape 2 Constant Growback model.
+            height (int): Height of the Sugarscape 2 Constant Growback model.
             initial_population: Number of population to start with
+            seed (int): Seed for the random number generator
+
         """
-        super().__init__()
+        super().__init__(seed=seed)
 
         # Set parameters
         self.width = width
         self.height = height
         self.initial_population = initial_population
 
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)
+        # self.grid = mesa.space.MultiGrid(self.width, self.height, torus=False)
+        self.grid = OrthogonalVonNeumannGrid((self.width, self.height), torus=True)
         self.datacollector = mesa.DataCollector(
             {"SsAgent": lambda m: len(m.agents_by_type[SsAgent])}
         )
@@ -46,10 +52,9 @@ def __init__(self, width=50, height=50, initial_population=100):
         import numpy as np
 
         sugar_distribution = np.genfromtxt(Path(__file__).parent / "sugar-map.txt")
-        for _, (x, y) in self.grid.coord_iter():
-            max_sugar = sugar_distribution[x, y]
-            sugar = Sugar(self, max_sugar)
-            self.grid.place_agent(sugar, (x, y))
+        for cell in self.grid.all_cells:
+            max_sugar = sugar_distribution[cell.coordinate]
+            Sugar(self, max_sugar, cell)
 
         # Create agent:
         for i in range(self.initial_population):
@@ -58,8 +63,8 @@ def __init__(self, width=50, height=50, initial_population=100):
             sugar = self.random.randrange(6, 25)
             metabolism = self.random.randrange(2, 4)
             vision = self.random.randrange(1, 6)
-            ssa = SsAgent(self, False, sugar, metabolism, vision)
-            self.grid.place_agent(ssa, (x, y))
+            cell = self.grid[(x,y)]
+            SsAgent(self, cell, sugar, metabolism, vision)
 
         self.running = True
         self.datacollector.collect(self)

examples/sugarscape_g1mt/sugarscape_g1mt/model.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 
 import mesa
+from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
+
 import numpy as np
 
 from .resource_agents import Resource
@@ -69,7 +71,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 +90,11 @@ 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 +113,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(
                 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/sugarscape_g1mt/sugarscape_g1mt/resource_agents.py

@@ -1,20 +1,22 @@
 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):
         """