move bank model to new OrthogonalMooreGrid

Author: quaquel

examples/bank_reserves/bank_reserves/agents.py

@@ -9,9 +9,7 @@
     Center for Connected Learning and Computer-Based Modeling,
     Northwestern University, Evanston, IL.
 """
-
-from .random_walk import RandomWalker
-
+from mesa.spaces import CellAgent
 
 class Bank:
     """Note that the Bank class is not a Mesa Agent, but just a regular Python
@@ -44,10 +42,10 @@ def bank_balance(self):
 
 
 # subclass of RandomWalker, which is subclass to Mesa Agent
-class Person(RandomWalker):
+class Person(CellAgent):
     def __init__(self, model, moore, bank, rich_threshold):
         # init parent class with required parameters
-        super().__init__(model, moore=moore)
+        super().__init__(model)
         # the amount each person has in savings
         self.savings = 0
         # total loan amount person has outstanding
@@ -67,15 +65,14 @@ def do_business(self):
         bank can loan them any money"""
         if self.savings > 0 or self.wallet > 0 or self.bank.bank_to_loan > 0:
             # create list of people at my location (includes self)
-            my_cell = self.model.grid.get_cell_list_contents([self.pos])
+
+
             # check if other people are at my location
-            if len(my_cell) > 1:
+            if len(self.cell.agents) > 1:
                 # set customer to self for while loop condition
                 customer = self
                 while customer == self:
-                    """select a random person from the people at my location
-                    to trade with"""
-                    customer = self.random.choice(my_cell)
+                    customer = self.random.choice(self.cell.agents)
                 # 50% chance of trading with customer
                 if self.random.randint(0, 1) == 0:
                     # 50% chance of trading $5
@@ -178,7 +175,7 @@ def take_out_loan(self, amount):
 
     def step(self):
         # move to a cell in my Moore neighborhood
-        self.random_move()
+        self.move_to(self.cell.neighborhood().select_random_cell())
         # trade
         self.do_business()
         # deposit money or take out a loan

examples/bank_reserves/bank_reserves/model.py

@@ -14,6 +14,7 @@
 import numpy as np
 
 from .agents import Bank, Person
+from mesa.spaces import OrthogonalMooreGrid
 
 """
 If you want to perform a parameter sweep, call batch_run.py instead of run.py.
@@ -78,7 +79,7 @@ def get_total_loans(model):
     return np.sum(agent_loans)
 
 
-class BankReserves(mesa.Model):
+class BankReservesModel(mesa.Model):
     """
     This model is a Mesa implementation of the Bank Reserves model from NetLogo.
     It is a highly abstracted, simplified model of an economy, with only one
@@ -117,7 +118,7 @@ def __init__(
         self.width = width
         self.init_people = init_people
 
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=True)
+        self.grid = OrthogonalMooreGrid((self.width, self.height), torus=True, random=self.random)
         # rich_threshold is the amount of savings a person needs to be considered "rich"
         self.rich_threshold = rich_threshold
         self.reserve_percent = reserve_percent
@@ -145,7 +146,7 @@ def __init__(
             y = self.random.randrange(self.height)
             p = Person(self, True, self.bank, self.rich_threshold)
             # place the Person object on the grid at coordinates (x, y)
-            self.grid.place_agent(p, (x, y))
+            p.move_to(self.grid[(x, y)])
 
         self.running = True
         self.datacollector.collect(self)

examples/bank_reserves/bank_reserves/random_walk.py

@@ -1,7 +1,7 @@
 import mesa
 
 from .agents import Person
-from .model import BankReserves
+from .model import BankReservesModel
 
 """
 Citation:

examples/bank_reserves/bank_reserves/server.py

@@ -29,70 +29,8 @@
 import mesa
 import numpy as np
 import pandas as pd
-from bank_reserves.agents import Bank, Person
-
-# Start of datacollector functions
-
-
-def get_num_rich_agents(model):
-    """list of rich agents"""
-
-    rich_agents = [a for a in model.agents if a.savings > model.rich_threshold]
-    # return number of rich agents
-    return len(rich_agents)
-
-
-def get_num_poor_agents(model):
-    """list of poor agents"""
-
-    poor_agents = [a for a in model.agents if a.loans > 10]
-    # return number of poor agents
-    return len(poor_agents)
-
-
-def get_num_mid_agents(model):
-    """list of middle class agents"""
-
-    mid_agents = [
-        a for a in model.agents if a.loans < 10 and a.savings < model.rich_threshold
-    ]
-    # return number of middle class agents
-    return len(mid_agents)
-
-
-def get_total_savings(model):
-    """list of amounts of all agents' savings"""
-
-    agent_savings = [a.savings for a in model.agents]
-    # return the sum of agents' savings
-    return np.sum(agent_savings)
-
-
-def get_total_wallets(model):
-    """list of amounts of all agents' wallets"""
-
-    agent_wallets = [a.wallet for a in model.agents]
-    # return the sum of all agents' wallets
-    return np.sum(agent_wallets)
-
-
-def get_total_money(model):
-    """sum of all agents' wallets"""
-
-    wallet_money = get_total_wallets(model)
-    # sum of all agents' savings
-    savings_money = get_total_savings(model)
-    # return sum of agents' wallets and savings for total money
-    return wallet_money + savings_money
-
-
-def get_total_loans(model):
-    """list of amounts of all agents' loans"""
-
-    agent_loans = [a.loans for a in model.agents]
-    # return sum of all agents' loans
-    return np.sum(agent_loans)
 
+from bank_reserves.model import BankReservesModel
 
 def track_params(model):
     return (model.init_people, model.rich_threshold, model.reserve_percent)
@@ -101,79 +39,6 @@ def track_params(model):
 def track_run(model):
     return model.uid
 
-
-class BankReservesModel(mesa.Model):
-    # id generator to track run number in batch run data
-    id_gen = itertools.count(1)
-
-    # grid height
-    grid_h = 20
-    # grid width
-    grid_w = 20
-
-    """init parameters "init_people", "rich_threshold", and "reserve_percent"
-       are all set via Slider"""
-
-    def __init__(
-        self,
-        height=grid_h,
-        width=grid_w,
-        init_people=2,
-        rich_threshold=10,
-        reserve_percent=50,
-    ):
-        super().__init__()
-        self.uid = next(self.id_gen)
-        self.height = height
-        self.width = width
-        self.init_people = init_people
-
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=True)
-        # rich_threshold is the amount of savings a person needs to be considered "rich"
-        self.rich_threshold = rich_threshold
-        self.reserve_percent = reserve_percent
-        # see datacollector functions above
-        self.datacollector = mesa.DataCollector(
-            model_reporters={
-                "Rich": get_num_rich_agents,
-                "Poor": get_num_poor_agents,
-                "Middle Class": get_num_mid_agents,
-                "Savings": get_total_savings,
-                "Wallets": get_total_wallets,
-                "Money": get_total_money,
-                "Loans": get_total_loans,
-                "Model Params": track_params,
-                "Run": track_run,
-            },
-            agent_reporters={"Wealth": "wealth"},
-        )
-
-        # create a single bank object for the model
-        self.bank = Bank(self, self.reserve_percent)
-
-        # create people for the model according to number of people set by user
-        for i in range(self.init_people):
-            # set x coordinate as a random number within the width of the grid
-            x = self.random.randrange(self.width)
-            # set y coordinate as a random number within the height of the grid
-            y = self.random.randrange(self.height)
-            p = Person(i, (x, y), self, True, self.bank, self.rich_threshold)
-            # place the Person object on the grid at coordinates (x, y)
-            self.grid.place_agent(p, (x, y))
-
-        self.running = True
-
-    def step(self):
-        # collect data
-        self.datacollector.collect(self)
-        # tell all the agents in the model to run their step function
-        self.agents.shuffle().do("step")
-
-    def run_model(self):
-        for i in range(self.run_time):
-            self.step()
-
-
 # parameter lists for each parameter to be tested in batch run
 br_params = {
     "init_people": [25, 100],