class ForestFire(Model): ''' Simple Forest Fire model. ''' def __init__(self, height, width, density): ''' Create a new forest fire model. Args: height, width: The size of the grid to model density: What fraction of grid cells have a tree in them. ''' # Initialize model parameters self.height = height self.width = width self.density = density # Set up model objects self.schedule = RandomActivation(self) self.grid = Grid(height, width, torus=False) self.datacollector = DataCollector( {"Fine": lambda m: self.count_type(m, "Fine"), "On Fire": lambda m: self.count_type(m, "On Fire"), "Burned Out": lambda m: self.count_type(m, "Burned Out")}) # Place a tree in each cell with Prob = density for (contents, x, y) in self.grid.coord_iter(): if random.random() < self.density: # Create a tree new_tree = TreeCell((x, y)) # Set all trees in the first column on fire. if x == 0: new_tree.condition = "On Fire" self.grid._place_agent((x, y), new_tree) self.schedule.add(new_tree) self.running = True def step(self): ''' Advance the model by one step. ''' self.schedule.step() self.datacollector.collect(self) # Halt if no more fire if self.count_type(self, "On Fire") == 0: self.running = False @staticmethod def count_type(model, tree_condition): ''' Helper method to count trees in a given condition in a given model. ''' count = 0 for tree in model.schedule.agents: if tree.condition == tree_condition: count += 1 return count
class SchellingModel(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height, width, density, minority_pc, homophily): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = Grid(height, width, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": lambda m: m.happy}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.x, "y": lambda a: a.y}) self.running = True # Set up agents for x in range(self.width): for y in range(self.height): if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x,y), x, y, agent_type) self.grid[y][x] = agent self.schedule.add(agent) def get_empty(self): ''' Get a list of coordinate tuples of currently-empty cells. ''' empty_cells = [] for x in range(self.width): for y in range(self.height): if self.grid[y][x] is None: empty_cells.append((x, y)) return empty_cells def step(self): ''' Run one step of the model. If All agents are happy, halt the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
class ShapesModel(Model): def __init__(self, N, width=20, height=10): self.running = True self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) self.make_walker_agents() def make_walker_agents(self): unique_id = 0 while True: if unique_id == self.N: break x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) pos = (x, y) heading = random.choice(self.headings) # heading = (1, 0) if self.grid.is_cell_empty(pos): print("Creating agent {2} at ({0}, {1})" .format(x, y, unique_id)) a = Walker(unique_id, self, pos, heading) self.schedule.add(a) self.grid.place_agent(a, pos) unique_id += 1 def step(self): self.schedule.step()
class MoneyModel(Model): """A model with some number of agents.""" def __init__(self, N, width, height): self.num_agents = N self.running = True self.grid = MultiGrid(height, width, True) self.schedule = RandomActivation(self) self.datacollector = DataCollector(model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda a: a.wealth}) # Create agents for i in range(self.num_agents): a = MoneyAgent(i) self.schedule.add(a) # Add the agent to a random grid cell x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) def step(self): self.datacollector.collect(self) self.schedule.step() def run_model(self, n): for i in range(n): self.step()
class WorldModel(Model): def __init__(self, N, width, height): self.grid = SingleGrid(height, width, True) self.schedule = RandomActivation(self) self.num_agents = N self.running = True for i in range(self.num_agents): ethnicity = random.choice(Ethnicities) a = PersonAgent(unique_id=i, model=self, ethnicity=int(ethnicity) ) self.schedule.add(a) # Add the agent to a random grid cell self.grid.position_agent(a) self.datacollector = DataCollector( agent_reporters={ "Nationalism": lambda a: a.nationalism, "X": lambda a: a.pos[0], "Y": lambda a: a.pos[1] } ) def step(self): self.datacollector.collect(self) self.schedule.step()
class WalkerWorld(Model): ''' Random walker world. ''' height = 10 width = 10 def __init__(self, height, width, agent_count): ''' Create a new WalkerWorld. Args: height, width: World size. agent_count: How many agents to create. ''' self.height = height self.width = width self.grid = MultiGrid(self.height, self.width, torus=True) self.agent_count = agent_count self.schedule = RandomActivation(self) # Create agents for i in range(self.agent_count): x = random.randrange(self.width) y = random.randrange(self.height) a = WalkerAgent((x, y), self, True) self.schedule.add(a) self.grid.place_agent(a, (x, y)) def step(self): self.schedule.step()
class Money_Model(Model): def __init__(self, N, width=50, height=50, torus=True): self.num_agents = N self.schedule = RandomActivation(self) self.grid = MultiGrid(height, width, torus) self.create_agents() self.dc = DataCollector({"Gini": lambda m: m.compute_gini()}, {"Wealth": lambda a: a.wealth}) self.running = True def create_agents(self): for i in range(self.num_agents): a = Money_Agent(i) self.schedule.add(a) x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) def step(self): self.dc.collect(self) self.schedule.step() def run_model(self, steps): for i in range(steps): self.step() def compute_gini(self): agent_wealths = [agent.wealth for agent in self.schedule.agents] x = sorted(agent_wealths) N = self.num_agents B = sum( xi * (N-i) for i,xi in enumerate(x) ) / (N*sum(x)) return (1 + (1/N) - 2*B)
class MoneyModel(Model): """A simple model of an economy where agents exchange currency at random. All the agents begin with one unit of currency, and each time step can give a unit of currency to another agent. Note how, over time, this produces a highly skewed distribution of wealth. """ def __init__(self, N, width, height): self.num_agents = N self.running = True self.grid = MultiGrid(height, width, True) self.schedule = RandomActivation(self) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda a: a.wealth} ) # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random grid cell x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) def step(self): self.datacollector.collect(self) self.schedule.step() def run_model(self, n): for i in range(n): self.step()
class BoltzmannWealthModelNetwork(Model): """A model with some number of agents.""" def __init__(self, num_agents=7, num_nodes=10): self.num_agents = num_agents self.num_nodes = num_nodes if num_nodes >= self.num_agents else self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=0.5) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda _: _.wealth} ) list_of_random_nodes = self.random.sample(self.G.nodes(), self.num_agents) # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random node self.grid.place_agent(a, list_of_random_nodes[i]) self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class Foraging(Model): number_of_bean = 0 number_of_corn = 0 number_of_soy = 0 def __init__(self, width=50, height=50, torus=True, num_bug=50, seed=42, strategy=None): super().__init__(seed=seed) self.number_of_bug = num_bug if not(strategy in ["stick", "switch"]): raise TypeError("'strategy' must be one of {stick, switch}") self.strategy = strategy self.grid = SingleGrid(width, height, torus) self.schedule = RandomActivation(self) data = {"Bean": lambda m: m.number_of_bean, "Corn": lambda m: m.number_of_corn, "Soy": lambda m: m.number_of_soy, "Bug": lambda m: m.number_of_bug, } self.datacollector = DataCollector(data) # create foods self._populate(Bean) self._populate(Corn) self._populate(Soy) # create bugs for i in range(self.number_of_bug): pos = self.grid.find_empty() bug = Bug(i, self) bug.strategy = self.strategy self.grid.place_agent(bug, pos) self.schedule.add(bug) def step(self): self.schedule.step() self.datacollector.collect(self) if not(self.grid.exists_empty_cells()): self.running = False def _populate(self, food_type): prefix = "number_of_{}" counter = 0 while counter < food_type.density * (self.grid.width * self.grid.height): pos = self.grid.find_empty() food = food_type(counter, self) self.grid.place_agent(food, pos) self.schedule.add(food) food_name = food_type.__name__.lower() attr_name = prefix.format(food_name) val = getattr(self, attr_name) val += 1 setattr(self, attr_name, val) counter += 1
class Charts(Model): # grid height grid_h = 20 # grid width grid_w = 20 """init parameters "init_people", "rich_threshold", and "reserve_percent" are all UserSettableParameters""" def __init__(self, height=grid_h, width=grid_w, init_people=2, rich_threshold=10, reserve_percent=50,): self.height = height self.width = width self.init_people = init_people self.schedule = RandomActivation(self) self.grid = 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 = 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}, agent_reporters={ "Wealth": lambda x: x.wealth}) # create a single bank for the model self.bank = Bank(1, 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, y coords randomly within the grid x = self.random.randrange(self.width) 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)) # add the Person object to the model schedule self.schedule.add(p) self.running = True self.datacollector.collect(self) def step(self): # tell all the agents in the model to run their step function self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self): for i in range(self.run_time): self.step()
class Schelling(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height=20, width=20, density=0.8, minority_pc=0.2, homophily=3): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.datacollector = DataCollector( {"happy": "happy"}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if self.random.random() < self.density: if self.random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) self.running = True self.datacollector.collect(self) def step(self): ''' Run one step of the model. If All agents are happy, halt the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step() # collect data self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
class SchellingModel(Model): """ Model class for the Schelling segregation model. """ def __init__(self, height, width, density, minority_pc, homophily): """ """ self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 self.total_agents = 0 self.datacollector = DataCollector( {"unhappy": lambda m: m.total_agents - m.happy}, # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[X], "y": lambda a: a.pos[Y]}, ) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell, x, y in self.grid.coord_iter(): if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent(self.total_agents, agent_type) self.grid.position_agent(agent, x, y) self.schedule.add(agent) self.total_agents += 1 def step(self): """ Run one step of the model. If All agents are happy, halt the model. """ self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.total_agents: self.running = False
class BoidModel(Model): ''' Flocker model class. Handles agent creation, placement and scheduling. ''' def __init__(self, population=100, width=100, height=100, speed=1, vision=10, separation=2, cohere=0.025, separate=0.25, match=0.04): ''' Create a new Flockers model. Args: population: Number of Boids width, height: Size of the space. speed: How fast should the Boids move. vision: How far around should each Boid look for its neighbors separation: What's the minimum distance each Boid will attempt to keep from any other cohere, separate, match: factors for the relative importance of the three drives. ''' self.population = population self.vision = vision self.speed = speed self.separation = separation self.schedule = RandomActivation(self) self.space = ContinuousSpace(width, height, True, grid_width=10, grid_height=10) self.factors = dict(cohere=cohere, separate=separate, match=match) self.make_agents() self.running = True def make_agents(self): ''' Create self.population agents, with random positions and starting headings. ''' for i in range(self.population): x = random.random() * self.space.x_max y = random.random() * self.space.y_max pos = np.array((x, y)) velocity = np.random.random(2) * 2 - 1 boid = Boid(i, self, pos, self.speed, velocity, self.vision, self.separation, **self.factors) self.space.place_agent(boid, pos) self.schedule.add(boid) def step(self): self.schedule.step()
class MoneyModel(Model): """A model with some number of agents.""" def __init__(self, N): self.num_agents = N self.schedule = RandomActivation(self) # Create agents for i in range(self.num_agents): a = MoneyAgent(i) self.schedule.add(a) def step(self): '''Advance the model by one step.''' self.schedule.step()
class VirusOnNetwork(Model): """A virus model with some number of agents""" def __init__(self, num_nodes=10, avg_node_degree=3, initial_outbreak_size=1, virus_spread_chance=0.4, virus_check_frequency=0.4, recovery_chance=0.3, gain_resistance_chance=0.5): 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 = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.datacollector = DataCollector({"Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant}) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED self.running = True self.datacollector.collect(self) def resistant_susceptible_ratio(self): try: return number_state(self, State.RESISTANT) / number_state(self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class InspectionModel(Model): ''' Simple Restaurant Inspection model. ''' def __init__(self, height, width, density): ''' Create a new restaurant inspection model. Args: height, width: The size of the grid to model density: What fraction of grid cells have a restaurant in them. ''' # Initialize model parameters self.height = height self.width = width self.density = density # Set up model objects self.schedule = RandomActivation(self) self.grid = Grid(height, width, torus=False) self.datacollector = DataCollector( {"Good": lambda m: self.count_type(m, "Good"), "Bad": lambda m: self.count_type(m, "Bad")}) # Place a restaurant in each cell with Prob = density for (contents, x, y) in self.grid.coord_iter(): if random.random() < self.density: # Create a restaurant new_restaurant = RestaurantCell((x, y)) self.grid._place_agent((x, y), new_restaurant) self.schedule.add(new_restaurant) self.running = True def step(self): ''' Advance the model by one step. ''' self.schedule.step() self.datacollector.collect(self) @staticmethod def count_type(model, restaurant_hygiene): ''' Helper method to count restaurants in a given condition in a given model. ''' count = 0 for restaurant in model.schedule.agents: if restaurant.hygiene == restaurant_hygiene and restaurant.rating != 'Closed': count += 1 return count
class SchellingModel(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height, width, density, type_pcs=[.2, .2, .2, .2, .2]): ''' ''' self.height = height self.width = width self.density = density self.type_pcs = type_pcs self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.happy = 0 self.datacollector = DataCollector( {"happy": lambda m: m.happy}, # Model-level count of happy agents # For testing purposes, agent's individual x and y {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) self.running = True # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) total_agents = self.height * self.width * self.density agents_by_type = [total_agents*val for val in self.type_pcs] for loc, types in enumerate(agents_by_type): for i in range(int(types)): pos = self.grid.find_empty() agent = SchellingAgent(pos, self, loc) self.grid.position_agent(agent, pos) self.schedule.add(agent) def step(self): ''' Run one step of the model. If All agents are happy, halt the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
class VirusModel(Model): """A virus model with some number of agents""" def __init__(self, num_nodes, avg_node_degree, initial_outbreak_size, virus_spread_chance, virus_check_frequency, recovery_chance, gain_resistance_chance): 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 = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.running = True self.datacollector = DataCollector({"Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant}) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED def resistant_susceptible_ratio(self): try: return number_state(self, State.RESISTANT) / number_state(self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class NewModel(Model): def __init__(self, width, height, num_agents): self.schedule = RandomActivation(self) self.grid = SingleGrid(width, height, torus = True) self.num_agents = num_agents # to collect info about how many agents are happy, average similarity of neighbors, length of residence self.datacollector = DataCollector(model_reporters = {"Happy": lambda m: m.happy, "Similar": lambda m: m.similar, "Residence": lambda m: m.avg_residence}, agent_reporters = {"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}) self.avg_residence = 0 self.happy = 0 self.similar = 0 self.running = True for i in range(self.num_agents): # white if random.random() < 0.70: agent_type = 1 income = np.random.normal(54000, 41000) # black else: agent_type = 0 income = np.random.normal(32000, 40000) # add new agents agent = NewAgent(i, self, agent_type, income) self.schedule.add(agent) # assign the initial coords of the agents x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.position_agent(agent, (x, y)) def step(self): '''Advance the model by one step.''' self.happy = 0 self.schedule.step() # get the average similarity self.similar /= self.num_agents # get the average length of residence self.avg_residence /= self.num_agents self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False
class SchellingModel(Model): """Model class for the Schelling segregation model.""" def __init__(self, density, minority_pc): self.density = density self.minority_pc = minority_pc self.schedule = RandomActivation(self) self.grid = GeoSpace(crs='epsg:4326') self.happy = 0 self.datacollector = DataCollector( {"happy": lambda m: m.happy}) # Model-level count of happy agents self.running = True # Set up the grid with patches for every NUTS region regions = geojson.load(open('nuts_rg_60M_2013_lvl_2.geojson')) self.grid.create_agents_from_GeoJSON(regions, SchellingAgent, model=self, unique_id='NUTS_ID') # Set up agents for agent in self.grid.agents: if random.random() < self.density: if random.random() < self.minority_pc: agent.atype = 1 else: agent.atype = 0 self.schedule.add(agent) # Update the bounding box of the grid and create a new rtree self.grid.update_bbox() self.grid.create_rtree() def step(self): """Run one step of the model. If All agents are happy, halt the model. """ self.happy = 0 # Reset counter of happy agents self.schedule.step() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False self.grid.create_rtree()
class WalkingModel(Model): def __init__(self, N, width, height): self.num_agents = N self.schedule = RandomActivation(self) self.grid = MultiGrid(width, height, True) self.running = True self.allAgents = [] # create a grid with travel(grocery, social areas), home, and work locations # self.allLocations = {} num_travel = int(self.num_agents / 10) # number of travel locations num_work = int(self.num_agents / 5) self.travelLocs = [(random.randint(0, width - 1), random.randint(0, height - 1)) for i in range(num_travel)] self.workLocs = [(random.randint(0, width - 1), random.randint(0, height - 1)) for i in range(num_work)] self.homeLocs = [] for i in range(self.num_agents): homeX, homeY = random.randint(0, width - 1), random.randint( 0, height - 1) while (homeX, homeY) in self.workLocs or ( homeX, homeY ) in self.travelLocs: # "reroll" the home location if it already exists homeX, homeY = random.randint(0, width - 1), random.randint( 0, height - 1) self.homeLocs.append((homeX, homeY)) agent = WalkingAgent(i, self, self.homeLocs[i], random.choice(self.workLocs)) self.schedule.add(agent) self.grid.place_agent(agent, agent.home) self.allAgents.append(agent) ## displaying how many of each location there are # homeCount = len(self.homeLocs) # workCount = len(self.workLocs) # travelCount = len(self.travelLocs) # print(homeCount, workCount, travelCount) def getWorkLocs(self): return self.workLocs def getHomeLocs(self): return self.homeLocs
class ScientistModel(Model): def __init__(self, N, ideas_per_time, time_periods): # Scalar: indicates the total number of scientists in the model # N is the number of scientists per time period self.num_scientists = N * time_periods # Scalar: number of ideas unique to each time period self.ideas_per_time = ideas_per_time # Scalar: total number of ideas in the model. +2 is used to account # for first two, non-steady state time periods self.total_ideas = ideas_per_time * (time_periods + 2) # Array: stores the max investment allowed for each idea self.max_investment = poisson(lam=10, size=self.total_ideas) # Array: store parameters for true idea return distribution self.true_sds = poisson(4, size=self.total_ideas) self.true_means = poisson(25, size=self.total_ideas) # Ensures that none of the standard devs are equal to 0 self.true_sds += 1 # Array: keeps track of total effort allocated to each idea across all # scientists self.total_effort = np.zeros(self.total_ideas) # Make scientists choose ideas and allocate effort in a random order # for each step of the model (i.e. within a time period, the order # in which young and old scientists get to invest in ideas is random) self.schedule = RandomActivation(self) for i in range(4, self.num_scientists + 4): a = Scientist(i, self) self.schedule.add(a) # Create data collector method for keeping track of variables over time self.datacollector = DataCollector( model_reporters={"Total effort": "total_effort"}, agent_reporters={ "Effort invested": "effort_invested", "Perceived returns": "perceived_returns" }) def step(self): # Call data collector to keep track of variables at each model step self.datacollector.collect(self) self.schedule.step()
class MoneyModel(Model): """A model with some number of agents.""" def __init__(self, N): self.num_agents = N # Create agents self.schedule = RandomActivation(self) # Create agents for i in range(self.num_agents): wages = float(randint(1, 10)) exp = random() / 2 a = MoneyAgent(i, wages, exp, self) self.schedule.add(a) def step(self): '''Advance the model by one step.''' self.schedule.step()
class Warehouse(Model): def __init__(self, world, tsp_seqs, last_sim_step): self.schedule = RandomActivation(self) self.world = world self.tsp_seq = tsp_seqs self.last_sim_step = last_sim_step self.time_step = 0 self.task_count = 0 self.grid = MultiGrid(world.width, world.height, torus=False) self.data_collector = DataCollector( {"task_count": "task_count"} ) self.robot_count = 0 # Set up MultiGrid from csv map for element in world: if world[element] == MAPNODETYPES.WALL: # Wall agent = Wall(element, self) self.grid.place_agent(agent, element) self.schedule.add(agent) # Task endpoint elif world[element] == MAPNODETYPES.TASK_ENDPOINT: agent = Space(element, self) self.grid.place_agent(agent, element) self.schedule.add(agent) # Robot spawn endpoint elif world[element] == MAPNODETYPES.PARKING: # Parking location agent = Parking(element, self) self.grid.place_agent(agent, element) self.schedule.add(agent) # Robot location (At park initially) self.robot_count += 1 agent = Robot(element, self, world.agents[self.robot_count].path) self.grid.place_agent(agent, element) self.schedule.add(agent) self.running = True def step(self): new_task_count = 0 # Update tasks counter for seq_id in self.tsp_seq: if self.tsp_seq[seq_id].qsize() > 0: if self.time_step >= self.tsp_seq[seq_id].queue[0].release_time: if self.time_step in self.world.agents[seq_id].path: if self.tsp_seq[seq_id].queue[0].delivery_endpoint == \ self.world.agents[seq_id].path[self.time_step]: self.tsp_seq[seq_id].get() new_task_count += self.tsp_seq[seq_id].qsize() self.task_count = new_task_count # Stop running once finished if self.time_step >= self.last_sim_step: self.running = False # Next step self.time_step += 1 self.schedule.step() self.data_collector.collect(self)
class Simulation(Model): """A model with some number of agents.""" def __init__(self, params, seed=None): #self.num_agents = params.get('num_persons') self.num_agents = int( params.get('density') * params.get('grid_x') * params.get('grid_y')) self.grid = MultiGrid(params.get('grid_x'), params.get('grid_y'), True) self.schedule = RandomActivation(self) self.start_infected = params.get('initial_infected') self.recovery_period = params.get('recovery_period') self.infect_rate = params.get('infect_rate') self.mortality_rate = params.get( 'mortality_rate') / self.recovery_period self.active_ratio = params.get('active_ratio') self.immunity_chance = params.get('immunity_chance') self.quarantine_rate = params.get('quarantine_rate') self.lockdown_rate = params.get('lockdown_rate') self.running = True self.current_cycle = 0 # Create agents for i in range(self.num_agents): a = Person(i, self) if self.random.random() < self.start_infected: a.set_infected() if self.random.random() < self.lockdown_rate: a.set_lockdown() self.schedule.add(a) # Add the agent to a random grid cell x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) self.datacollector = DataCollector( model_reporters={ "Infected": total_infected, "Deaths": total_deaths, "Immune": total_immune }) def step(self): '''Advance the model by one step.''' self.datacollector.collect(self) self.schedule.step() self.current_cycle += 1
class SegregationModel(Model): def __init__(self, number_of_agents, width, height, happiness_threshold, minority_rate): self.num_agents = number_of_agents self.grid = MultiGrid(width, height, False) self.schedule = RandomActivation(self) ## Create Agents number_of_minority = round(number_of_agents * (minority_rate)) for i in range(number_of_agents): if (i + 1) <= number_of_minority: ethnicity = 1 else: ethnicity = 2 a = SegregationAgent(i, ethnicity, happiness_threshold, self) self.schedule.add(a) # place agent on grid # x = self.random.randrange(self.grid.width) # y = self.random.randrange(self.grid.height) empty_place = self.grid.find_empty() self.grid.place_agent(a, empty_place) logger.info("Agent " + str(i) + " placed in " + str(empty_place)) self.datacollector = DataCollector( agent_reporters={"Happiness": "happy"}, model_reporters={"Overall_happiness": overall_happiness}, ) def plot_grid(self): ethnicities = np.zeros((self.grid.width, self.grid.height)) for cell in self.grid.coord_iter(): cell_content, x, y = cell agent_present = len(cell_content) if agent_present > 0: cell_content = list(cell_content) ethnicities[x][y] = cell_content[0].ethnicity plt.imshow(ethnicities, interpolation="nearest") plt.colorbar() plt.show() def step(self): self.datacollector.collect(self) self.schedule.step() self.plot_grid()
class SchellingModel(Model): ''' Model class for the Schelling segregation model. ''' def __init__(self, height=50, width=50, density=0.8, minority_pc=0.5, homophily=3): ''' ''' self.height = height self.width = width self.density = density self.minority_pc = minority_pc self.homophily = homophily self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=True) self.happy = 0 # Set up agents # We use a grid iterator that returns # the coordinates of a cell as well as # its contents. (coord_iter) for cell in self.grid.coord_iter(): x = cell[1] y = cell[2] if random.random() < self.density: if random.random() < self.minority_pc: agent_type = 1 else: agent_type = 0 agent = SchellingAgent((x, y), self, agent_type) self.grid.position_agent(agent, (x, y)) self.schedule.add(agent) def step(self): ''' Run one step of the model. ''' self.happy = 0 # Reset counter of happy agents self.schedule.step()
class BoidModel(Model): ''' Flocker model class. Handles agent creation, placement and scheduling. ''' N = 100 width = 100 height = 100 def __init__(self, N, width, height, speed, vision, separation): ''' Create a new Flockers model. Args: N: Number of Boids width, height: Size of the space. speed: How fast should the Boids move. vision: How far around should each Boid look for its neighbors separtion: What's the minimum distance each Boid will attempt to keep from any other ''' self.N = N self.vision = vision self.speed = speed self.separation = separation self.schedule = RandomActivation(self) self.space = ContinuousSpace(width, height, True, grid_width=10, grid_height=10) self.make_agents() self.running = True def make_agents(self): ''' Create N agents, with random positions and starting headings. ''' for i in range(self.N): x = random.random() * self.space.x_max y = random.random() * self.space.y_max pos = (x, y) heading = np.random.random(2) * 2 - np.array((1, 1)) heading /= np.linalg.norm(heading) boid = Boid(i, pos, self.speed, heading, self.vision, self.separation) self.space.place_agent(boid, pos) self.schedule.add(boid) def step(self): self.schedule.step()
class ArgumentModel(Model): """ ArgumentModel which inherit from Model. """ def __init__(self): self.schedule = RandomActivation(self) self.__messages_service = MessageService(self.schedule) Item1 = Item('Item1', description='first item') Item2 = Item('Item2', description='second item') self.list_items = [Item1, Item2] for i in range(2): a = ArgumentAgent(i, self, "Agent" + str(i), self.list_items) self.schedule.add(a) self.running = True def step(self): self.__messages_service.dispatch_messages() self.schedule.step()
class AlertSystem(Model): """A model with some number of agents.""" def __init__(self, server=None): self.agents = [AlertAgent, DialAgent] self.schedule = RandomActivation(self) if server is not None: self.server = server else: self.server = Server(system=self) # Create agents for i, ag in enumerate(self.agents): a = ag(i, self) self.schedule.add(a) def step(self): '''Advance the model by one step.''' self.schedule.step()
class FirmModel(Model): """A model with some number of agents.""" def __init__(self, N): self.alpha = 0.5 self.beta = 1 - self.alpha self.num_agents = N # Create agents self.schedule = RandomActivation(self) # Create agents for i in range(self.num_agents): exp = random() a = FirmAgent(i, exp, self) self.schedule.add(a) def step(self): '''Advance the model by one step.''' self.schedule.step()
class MoneyModel(Model): def __init__(self, number_of_agents, width, height): self.num_agents = number_of_agents self.grid = MultiGrid(width, height, True) self.schedule = RandomActivation(self) # Create agents for i in range(number_of_agents): a = MoneyAgent(i, self) self.schedule.add(a) ## place agent on grid x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) # start datacollector self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": "wealth"}, ) def plot_grid(self): agent_counts = np.zeros((self.grid.width, model.grid.height)) for cell in self.grid.coord_iter(): cell_content, x, y = cell agent_count = len(cell_content) agent_counts[x][y] = agent_count plt.imshow(agent_counts, interpolation="nearest") plt.colorbar() plt.show() def step(self): # Advance the model by one step self.datacollector.collect(self) self.schedule.step() self.plot_grid() def check_agent_status(self): for i in range(len(self.schedule.agents)): id = self.schedule.agents[i].unique_id wealth = self.schedule.agents[i].wealth logger.info("Agent " + str(id) + " has money: " + str(wealth))
class BirdModel(Model): def __init__(self, n, width, height, algorithm="Dummy"): self.score_for_food = 10 self.score_for_death = 100 self.num_agents = n self.num_predator = round(n/4) self.growth_time = 2 self.grid = Space(width, height, True) self.schedule = Activation(self) self.max_food_id = 0 self.running = True for i in range(self.num_agents): if algorithm == "Dummy": bird = BirdAgent(i, self) elif algorithm == "Q": raise NotImplementedError elif algorithm == "GA": raise NotImplementedError elif algorithm == "DRL": raise NotImplementedError self.schedule.add(bird) x = random.randint(0, self.grid.width-1) y = random.randint(0, self.grid.height-1) self.grid.place_agent(bird, (x, y)) for j in range(i + 1, i + 1 + self.num_predator): predator = PredatorAgent(j, self) self.schedule.add(predator) x = random.randint(0, self.grid.width - 1) y = random.randint(0, self.grid.height - 1) self.grid.place_agent(predator, (x, y)) self.dc = DataCollector( model_reporters={"TotalScore": total_score}, agent_reporters={"Score": "score"}) def step(self): if self.schedule.time % self.growth_time == 0: self.max_food_id += 1 food = FoodAgent(self.max_food_id, self) x = random.randint(0, self.grid.width-1) y = random.randint(0, self.grid.height-1) self.grid.place_agent(food, (x, y)) self.dc.collect(self) self.schedule.step()
class Disease_Model(Model): # 2D Model initialisation function - initialise with N agents, and # specified width and height """A model of disease spread. For training purposes only.""" def __init__(self, N, width, height, initial_infection, transmissibility, level_of_movement, mean_length_of_disease): self.running = True # required for BatchRunner self.num_agents = N # assign number of agents at initialisation self.grid = MultiGrid(width, height, True) # setup Toroidal multi-grid # set up a scheduler with random order of agents being activated # each turn self.schedule = RandomActivation(self) # Create agents up to number specified for i in range(self.num_agents): # Create agent with ID taken from for loop a = Person_Agent(i, self, initial_infection, transmissibility, level_of_movement, mean_length_of_disease) self.schedule.add(a) # add agent to the schedule # Try adding the agent to a random empty cell try: start_cell = self.grid.find_empty() self.grid.place_agent(a, start_cell) # If you can't find an empty cell, just pick any cell at random except: x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) # Create a new datacollector, and pass in a model reporter as a # dictionary entry, with the index value as the name of the result # (which we'll refer to by this name elsewhere) and the lookup value # as the name of the function we created below that will calculate # the result we're reporting self.datacollector = DataCollector( model_reporters={"Total_Infected": calculate_number_infected}, agent_reporters={}) # Function to advance the model by one step def step(self): self.schedule.step() # Tell the datacollector to collect data from the specified model # and agent reporters self.datacollector.collect(self)
class ShapesModel(Model): def __init__(self, N, width=20, height=10): self.running = True self.N = N # num of agents self.headings = ((1, 0), (0, 1), (-1, 0), (0, -1)) # tuples are fast self.grid = SingleGrid(width, height, torus=False) self.schedule = RandomActivation(self) load_scene('shape_model/crossing.txt', self.grid, self) """ self.grid.place_agent( Walker(1911, self, (4, 4), type="wall"), (4, 4) ) self.make_walls() self.make_walker_agents() """ def make_walls(self): for i in range(0, 50): self.grid.place_agent(Walker(1911, self, (i, 5), type="wall"), (i, 5)) def make_walker_agents(self): unique_id = 0 while True: if unique_id == self.N: break x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) pos = (x, y) heading = random.choice(self.headings) # heading = (1, 0) if self.grid.is_cell_empty(pos): print("Creating agent {2} at ({0}, {1})".format( x, y, unique_id)) a = Walker(unique_id, self, pos, heading) self.schedule.add(a) self.grid.place_agent(a, (x, y)) self.grid.place_agent(a, (x + 1, y)) self.grid.place_agent(a, (x, y + 1)) self.grid.place_agent(a, (x + 1, y + 1)) unique_id += 1 def step(self): self.schedule.step()
class MoneyModel(Model): """A model with some number of agents.""" def __init__(self, N, width, height): self.num_agents = N self.grid = MultiGrid(width, height, True) self.schedule = RandomActivation(self) self.running = True # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random grid cell x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) def step(self): self.schedule.step()
class CivModel(Model): """A model with some number of agents.""" def __init__(self, N, width, height): self.num_agents = N self.grid = MultiGrid(width, height, True) self.schedule = RandomActivation(self) # Créer une timeline for i in range(self.num_agents): agent = CivAgent(i, self) self.schedule.add(agent) # ajoute N agent à la timeline # positionne aléatoirement l'agent sur la grille x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.place_agent(agent, (x, y)) def step(self): self.schedule.step()
class mkt(Model): def __init__(self, N, K): super().__init__() self.N = N self.K = K self.consume = False self.trade = True self.solo_update = True self.money = False self.history = [] self.schedule = RandomActivation(self) # create agents for a in range(self.N): a = ant(a, self) self.schedule.add(a) def step(self): self.schedule.step()
class TaxiModel(Model): """A model with some number of agents.""" def __init__(self, N): self.schedule = RandomActivation(self) call_center = CallCenterAgent(1,N,self) self.schedule.add(call_center) self.datacollector = DataCollector( agent_reporters={ "Wealth": lambda call_center: call_center.wealth, "Mu": lambda call_center: call_center.mu, "Number_Agent": lambda call_center: call_center.number_taxi_working, "Taxi": lambda call_center: call_center.list_taxis_wealth }) def step(self): self.schedule.step() self.datacollector.collect(self)
class PredictionMarketModel(Model): """A simple model of a market where people bid/ask for prediciton shares. """ def __init__(self, N=100): self.num_agents = N self.schedule = RandomActivation(self) self.datacollector = DataCollector(model_reporters={ "bid_price": get_highest_bid, "ask_price": get_lowest_ask, "volume": compute_volume }, agent_reporters={ "Certainty": "prob", "Bids": "bid", "Asks": "ask" }) self.bidders = OrderedDict() self.askers = OrderedDict() self.volume = 0 # Create agents print('creating {} agents..'.format(self.num_agents)) for i in range(self.num_agents): # Create probability distribution #prob = np.random.normal(mu, sigma) #prob = np.random.uniform(0.01, 0.99) if random.randint(0, 1): prob = np.random.normal(0.83, 0.05) else: prob = np.random.normal(0.53, 0.05) a = PredictionAgent(prob, i, self) self.schedule.add(a) print('running model...') self.running = True def step(self): self.volume = 0 self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class Disease_Model(Model): # 2D Model initialisation function - initialise with N agents, and # specified width and height. Also pass in the things we need to pass # to our agents when instantiating them. # The comment below which uses triple " will get picked up by the server # if we run a live display of the model. """A model of disease spread. For training purposes only.""" def __init__(self, N, width, height, initial_infection, transmissibility, level_of_movement, mean_length_of_disease): self.running = True # required for BatchRunner self.num_agents = N # assign number of agents at initialisation # Set up a Toroidal multi-grid (Toroidal = if the agent is in a cell # on the border of the grid, and moves towards the border, they'll # come out the other side. Think PacMan :) The True Boolean passed in # switches that on. Multi-Grid just means we can have more than one # agent per cell) self.grid = MultiGrid(width, height, True) # set up a scheduler with random order of agents being activated # each turn. Remember order is important here - if an infected agent # is going to move into a cell with an uninfected agent, but that # uninfected agent moves first, they'll escape infection. self.schedule = RandomActivation(self) # Create person_agent objects up to number specified for i in range(self.num_agents): # Create agent with ID taken from for loop a = Person_Agent(i, self, initial_infection, transmissibility, level_of_movement, mean_length_of_disease) self.schedule.add(a) # add agent to the schedule # Try adding the agent to a random empty cell try: start_cell = self.grid.find_empty() self.grid.place_agent(a, start_cell) # If you can't find an empty cell, just pick any cell at random except: x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) # Function to advance the model by one step def step(self): self.schedule.step()
class mkt(Model): def __init__(self, N, K, width=10, height=10, trade=True): super().__init__() self.N = N self.K = K self.consume = False self.trade = trade self.solo_update = True self.money = False self.running = True self.history = [] self.grid = MultiGrid(width, height, True) self.schedule = RandomActivation(self) # create agents for a in range(self.N): a = ant(a, self) self.schedule.add(a) x = self.random.randrange(self.grid.width) y = self.random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) all_utility = [agent.utility() for agent in self.schedule.agents] self.mean_utility = sum(all_utility) / self.N all_spec = [agent.specialization() for agent in self.schedule.agents] self.mean_specialization = sum(all_spec) / self.N self.datacollector = DataCollector(model_reporters={ "Mean_Utility": "mean_utility", "Mean_Specialization": "mean_specialization" }, agent_reporters={ "Utility": utility_reporter, "Specialization": specialization_reporter }) def step(self): self.schedule.step() self.datacollector.collect(self) all_utility = [agent.utility() for agent in self.schedule.agents] self.mean_utility = sum(all_utility) / self.N all_spec = [agent.specialization() for agent in self.schedule.agents] self.mean_specialization = np.mean(all_spec) / self.N
class Disease_Model(Model): # 2D Model initialisation function - initialise with N agents, and # specified width and height """A model of disease spread. For training purposes only.""" def __init__(self, N, width, height, initial_infection, transmissibility, level_of_movement, mean_length_of_disease, mean_imm_duration, prob_being_immunised): self.running = True # required for BatchRunner self.num_agents = N # assign number of agents at initialisation self.grid = MultiGrid(width, height, True) # setup Toroidal multi-grid # set up a scheduler with random order of agents being activated # each turn self.schedule = RandomActivation(self) # Create agents up to number specified for i in range(self.num_agents): # Create agent with ID taken from for loop a = Person_Agent(i, self, initial_infection, transmissibility, level_of_movement, mean_length_of_disease, mean_imm_duration, prob_being_immunised) self.schedule.add(a) # add agent to the schedule # Try adding the agent to a random empty cell try: start_cell = self.grid.find_empty() self.grid.place_agent(a, start_cell) # If you can't find an empty cell, just pick any cell at random except: x = random.randrange(self.grid.width) y = random.randrange(self.grid.height) self.grid.place_agent(a, (x, y)) self.datacollector = DataCollector(model_reporters={ "Total_Infected": calculate_number_infected, "Total_Imm": calculate_number_immunised }, agent_reporters={}) # Function to advance the model by one step def step(self): self.schedule.step() self.datacollector.collect(self)
class MoneyModel(Model): """A model with some number of agents""" def __init__(self, N): self.num_agents = N self.schedule = RandomActivation(self) #create agents for i in range(self.num_agents): #here is the agent definition a = MoneyAgent( i, self ) #i becomes the unique id. Use of self here is still a question... self.schedule.add(a) def step(self): '''Ádvance the model by one step''' #print(self.num_agents) self.schedule.step( ) #it shuffles the order of the agents, then activates them all, one at a time.
class ForestFire(Model): def __init__(self, height=100, width=100, density=0.65): self.height = height self.width = width self.density = density self.schedule = RandomActivation(self) self.grid = Grid(height, width, torus=False) self.datacollector = DataCollector({ "Fine": lambda m: self.count_type(m, "Fine"), "On Fire": lambda m: self.count_type(m, "On Fire"), "Burned Out": lambda m: self.count_type(m, "Burned Out"), }) for (contents, x, y) in self.grid.coord_iter(): if self.random.random() < self.density: new_tree = TreeCell((x, y), self) # Set all trees in the first column on fire. if x == 0: new_tree.condition = "On Fire" self.grid._place_agent((x, y), new_tree) self.schedule.add(new_tree) self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() self.datacollector.collect(self) # Halt if no more fire if self.count_type(self, "On Fire") == 0: self.running = False @staticmethod def count_type(model, tree_condition): count = 0 for tree in model.schedule.agents: if tree.condition == tree_condition: count += 1 return count
class MowerModel(Model): """A model with 1 Mower.""" def __init__(self, N, width, height): super().__init__( ) # !!IMPORTANT : https://github.com/projectmesa/mesa/issues/627 self.num_agents = N self.direction = 'R' self.grid = MultiGrid(width, height, True) self.schedule = RandomActivation(self) # Create agents for i in range(self.num_agents): a = MowerAgent(i, self) self.schedule.add(a) # Add the agent to a random grid cell self.grid.place_agent(a, tuple([0, 0])) def step(self): self.schedule.step()
class MoneyModel(Model): def __init__(self,N,width,height): self.running = True self.num_agents = N self.grid = MultiGrid(width, height,True) self.schedule = RandomActivation(self) for i in range(self.num_agents): a=MoneyAgent(i, self) self.schedule.add(a) x=random.randrange(self.grid.width) y=random.randrange(self.grid.height) self.grid.place_agent(a,(x,y)) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, # A function to call agent_reporters={"Wealth": "wealth"}) # An agent attribute def step(self): self.datacollector.collect(self) self.schedule.step()
class MoneyModel(Model): """A model with some number of agents.""" def __init__(self, N): self.running = True self.num_agents = N self.schedule = RandomActivation(self) self.create_agents() agent_reporters = {"Wealth": lambda a: a.wealth} model_reporters = {"Gini": compute_gini} self.dc = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) def create_agents(self): """Method to create all the agents.""" for i in range(self.num_agents): a = MoneyAgent(i) self.schedule.add(a) def step(self): self.schedule.step() self.dc.collect(self)
class LifeTimeModel(Model): '''Simple model for running models with a finite life''' def __init__(self, agent_lifetime = 1, n_agents = 10): super().__init__() self.agent_lifetime = agent_lifetime self.n_agents = n_agents ## keep track of the the remaining life of an agent and ## how many ticks it has seen self.datacollector = DataCollector( agent_reporters = {"remaining_life" : lambda a: a.remaining_life, "steps" : lambda a: a.steps}) self.current_ID = 0 self.schedule = RandomActivation(self) for _ in range(n_agents): self.schedule.add(FiniteLifeAgent(self.next_id(), self.agent_lifetime, self)) def step(self): '''Add agents back to n_agents in each step''' self.datacollector.collect(self) self.schedule.step() if len(self.schedule.agents) < self.n_agents: for _ in range(self.n_agents - len(self.schedule.agents)): self.schedule.add(FiniteLifeAgent(self.next_id(), self.agent_lifetime, self)) def run_model(self, step_count = 100): for _ in range(step_count): self.step()
class SchellingModel(Model): '''Model class for Schelling segregation model''' def __init__(self, height=20, width=20, density=.8, group_ratio=.66, minority_ratio=.5, homophily=3): self.height = height self.width = width self.density = density self.group_ratio = group_ratio self.minority_ratio = minority_ratio self.homophily = homophily self.happy = 0 self.segregated = 0 self.schedule = RandomActivation(self) self.grid = SingleGrid(height, width, torus=False) self.place_agents() self.datacollector = DataCollector( {'happy': (lambda m: m.happy), 'segregated': (lambda m: m.segregated)}) self.running = True def step(self): '''Run one step of model''' self.schedule.step() self.calculate_stats() self.datacollector.collect(self) if self.happy == self.schedule.get_agent_count(): self.running = False def place_agents(self): for cell in self.grid.coord_iter(): x, y = cell[1:3] if random.random() < self.density: if random.random() < self.group_ratio: if random.random() < self.minority_ratio: group = 0 else: group = 1 else: group = 2 agent = SchellingAgent((x,y), group) self.grid.position_agent(agent, (x,y)) self.schedule.add(agent) for agent in self.schedule.agents: count = 0 for neighbour in self.grid.iter_neighbors(agent.pos, moore=False): if neighbour.group == agent.group: count += 1 agent.similar = count def calculate_stats(self): happy_count = 0 avg_seg = 0 for agent in self.schedule.agents: avg_seg += agent.similar if agent.similar >= self.homophily: happy_count += 1 self.happy = happy_count self.segregated = avg_seg/self.schedule.get_agent_count()
class BankReserves(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 type of agent and a single bank representing all banks in an economy. People (represented by circles) move randomly within the grid. If two or more people are on the same grid location, there is a 50% chance that they will trade with each other. If they trade, there is an equal chance of giving the other agent $5 or $2. A positive trade balance will be deposited in the bank as savings. If trading results in a negative balance, the agent will try to withdraw from its savings to cover the balance. If it does not have enough savings to cover the negative balance, it will take out a loan from the bank to cover the difference. The bank is required to keep a certain percentage of deposits as reserves and the bank's ability to loan at any given time is a function of the amount of deposits, its reserves, and its current total outstanding loan amount. """ # grid height grid_h = 20 # grid width grid_w = 20 """init parameters "init_people", "rich_threshold", and "reserve_percent" are all UserSettableParameters""" def __init__(self, height=grid_h, width=grid_w, init_people=2, rich_threshold=10, reserve_percent=50,): self.height = height self.width = width self.init_people = init_people self.schedule = RandomActivation(self) self.grid = 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 = 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}, agent_reporters={ "Wealth": lambda x: x.wealth}) # create a single bank for the model self.bank = Bank(1, 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, y coords randomly within the grid x = self.random.randrange(self.width) 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)) # add the Person object to the model schedule self.schedule.add(p) self.running = True self.datacollector.collect(self) def step(self): # tell all the agents in the model to run their step function self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self): for i in range(self.run_time): self.step()
class WolfSheepPredation(Model): ''' Wolf-Sheep Predation Model ''' initial_sheep = 100 initial_wolves = 50 sheep_gain_from_food = 4 grass = False wolf_gain_from_food = 20 sheep_reproduce = 0.04 wolf_reproduce = 0.05 height = 20 width = 20 def __init__(self, height=20, width=20, initial_sheep=100, initial_wolves=50, sheep_reproduce=0.04, wolf_reproduce=0.05, wolf_gain_from_food=20, grass=False, sheep_gain_from_food=4): ''' Create a new Wolf-Sheep model with the given parameters. Args: initial_sheep: Number of sheep to start with initial_wolves: Number of wolves to start with sheep_reproduce: Probability of each sheep reproducing each step wolf_reproduce: Probability of each wolf reproducing each step wolf_gain_from_food: Energy a wolf gains from eating a sheep grass: Whether to have the sheep eat grass for energy sheep_gain_from_food: Energy sheep gain from grass, if enabled. ''' # Set parameters self.height = height self.width = width self.initial_sheep = initial_sheep self.initial_wolves = initial_wolves self.sheep_reproduce = sheep_reproduce self.wolf_reproduce = wolf_reproduce self.wolf_gain_from_food = wolf_gain_from_food self.grass = grass self.sheep_gain_from_food = sheep_gain_from_food self.schedule = RandomActivation(self) self.grid = MultiGrid(self.height, self.width, torus=True) # Create sheep: for i in range(self.initial_sheep): x = random.randrange(self.width) y = random.randrange(self.height) sheep = Sheep(self.grid, x, y, True) self.grid.place_agent(sheep, (x, y)) self.schedule.add(sheep) # Create wolves for i in range(self.initial_wolves): x = random.randrange(self.width) y = random.randrange(self.height) energy = random.randrange(2 * self.wolf_gain_from_food) wolf = Wolf(self.grid, x, y, True, energy) self.grid.place_agent(wolf, (x, y)) self.schedule.add(wolf) self.running = True def step(self): self.schedule.step()
class CivilViolenceModel(Model): """ Model 1 from "Modeling civil violence: An agent-based computational approach," by Joshua Epstein. http://www.pnas.org/content/99/suppl_3/7243.full Attributes: height: grid height width: grid width citizen_density: approximate % of cells occupied by citizens. cop_density: approximate % of calles occupied by cops. citizen_vision: number of cells in each direction (N, S, E and W) that citizen can inspect cop_vision: number of cells in each direction (N, S, E and W) that cop can inspect legitimacy: (L) citizens' perception of regime legitimacy, equal across all citizens max_jail_term: (J_max) active_threshold: if (grievance - (risk_aversion * arrest_probability)) > threshold, citizen rebels arrest_prob_constant: set to ensure agents make plausible arrest probability estimates movement: binary, whether agents try to move at step end max_iters: model may not have a natural stopping point, so we set a max. """ def __init__(self, height, width, citizen_density, cop_density, citizen_vision, cop_vision, legitimacy, max_jail_term, active_threshold=.1, arrest_prob_constant=2.3, movement=True, max_iters=1000): super(CivilViolenceModel, self).__init__() self.height = height self.width = width self.citizen_density = citizen_density self.cop_density = cop_density self.citizen_vision = citizen_vision self.cop_vision = cop_vision self.legitimacy = legitimacy self.max_jail_term = max_jail_term self.active_threshold = active_threshold self.arrest_prob_constant = arrest_prob_constant self.movement = movement self.running = True self.max_iters = max_iters self.iteration = 0 self.schedule = RandomActivation(self) self.grid = Grid(height, width, torus=True) model_reporters = { "Quiescent": lambda m: self.count_type_citizens(m, "Quiescent"), "Active": lambda m: self.count_type_citizens(m, "Active"), "Jailed": lambda m: self.count_jailed(m)} agent_reporters = { "x": lambda a: a.pos[0], "y": lambda a: a.pos[1], 'breed': lambda a: a.breed, "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) } self.dc = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) unique_id = 0 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(): if random.random() < self.cop_density: cop = Cop(unique_id, (x, y), vision=self.cop_vision, model=self) unique_id += 1 self.grid[y][x] = cop self.schedule.add(cop) elif random.random() < ( self.cop_density + self.citizen_density): citizen = Citizen(unique_id, (x, y), hardship=random.random(), regime_legitimacy=self.legitimacy, risk_aversion=random.random(), threshold=self.active_threshold, vision=self.citizen_vision, model=self) unique_id += 1 self.grid[y][x] = citizen self.schedule.add(citizen) def step(self): """ Advance the model by one step and collect data. """ self.schedule.step() self.dc.collect(self) self.iteration += 1 if self.iteration > self.max_iters: self.running = False @staticmethod def count_type_citizens(model, condition, exclude_jailed=True): """ Helper method to count agents by Quiescent/Active. """ count = 0 for agent in model.schedule.agents: if agent.breed == 'cop': continue if exclude_jailed and agent.jail_sentence: continue if agent.condition == condition: count += 1 return count @staticmethod def count_jailed(model): """ Helper method to count jailed agents. """ count = 0 for agent in model.schedule.agents: if agent.breed == 'citizen' and agent.jail_sentence: count += 1 return count
class SeparationBarrierModel(Model): def __init__(self, height, width, palestinian_density, settlement_density, settlers_violence_rate, settlers_growth_rate, suicide_rate, greed_level, settler_vision=1, palestinian_vision=1, movement=True, max_iters=1000): super(SeparationBarrierModel, self).__init__() self.height = height self.width = width self.palestinian_density = palestinian_density self.settler_vision = settler_vision self.palestinian_vision = palestinian_vision self.settlement_density = settlement_density self.movement = movement self.running = True self.max_iters = max_iters self.iteration = 0 self.schedule = RandomActivation(self) self.settlers_violence_rate = settlers_violence_rate self.settlers_growth_rate = settlers_growth_rate self.suicide_rate = suicide_rate self.greed_level = greed_level self.total_violence = 0 self.grid = SingleGrid(height, width, torus=False) model_reporters = { } agent_reporters = { # "x": lambda a: a.pos[0], # "y": lambda a: a.pos[1], } self.dc = DataCollector(model_reporters=model_reporters, agent_reporters=agent_reporters) self.unique_id = 0 # Israelis and palestinans split the region in half for (contents, x, y) in self.grid.coord_iter(): if random.random() < self.palestinian_density: palestinian = Palestinian(self.unique_id, (x, y), vision=self.palestinian_vision, breed="Palestinian", model=self) self.unique_id += 1 self.grid.position_agent(palestinian, x,y) self.schedule.add(palestinian) elif ((y > (self.grid.height) * (1-self.settlement_density)) and random.random() < self.settlement_density): settler = Settler(self.unique_id, (x, y), vision=self.settler_vision, model=self, breed="Settler") self.unique_id += 1 self.grid.position_agent(settler, x,y) self.schedule.add(settler) def add_settler(self, pos): settler = Settler(self.unique_id, pos, vision=self.settler_vision, model=self, breed="Settler") self.unique_id += 1 self.grid.position_agent(settler, pos[0], pos[1]) self.schedule.add(settler) def set_barrier(self,victim_pos, violent_pos): #print("Set barrier - Greed level", self.greed_level) visible_spots = self.grid.get_neighborhood(victim_pos, moore=True, radius=self.greed_level + 1) furthest_empty = self.find_furthest_empty_or_palestinian(victim_pos, visible_spots) x,y = furthest_empty current = self.grid[y][x] #print ("Set barrier!!", pos, current) free = True if (current is not None and current.breed == "Palestinian"): #print ("Relocating Palestinian") free = self.relocate_palestinian(current, current.pos) if (free): barrier = Barrier(-1, furthest_empty, model=self) self.grid.position_agent(barrier, x,y) # Relocate the violent palestinian #violent_x, violent_y = violent_pos #if violent_pos != furthest_empty: # violent_palestinian = self.grid[violent_y][violent_x] # self.relocate_palestinian(violent_palestinian, furthest_empty) def relocate_palestinian(self, palestinian, destination): #print ("Relocating Palestinian in ", palestinian.pos, "To somehwhere near ", destination) visible_spots = self.grid.get_neighborhood(destination, moore=True, radius=palestinian.vision) nearest_empty = self.find_nearest_empty(destination, visible_spots) #print("First Nearest empty to ", palestinian.pos, " Is ", nearest_empty) if (nearest_empty): self.grid.move_agent(palestinian, nearest_empty) else: #print ("Moveing to random empty") if (self.grid.exists_empty_cells()): self.grid.move_to_empty(palestinian) else: return False return True def find_nearest_empty(self, pos, neighborhood): nearest_empty = None sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood) index = 0 while (nearest_empty is None and index < len(sorted_spots)): if self.grid.is_cell_empty(sorted_spots[index]): nearest_empty = sorted_spots[index] index += 1 return nearest_empty def find_furthest_empty_or_palestinian(self, pos, neighborhood): furthest_empty = None sorted_spots = self.sort_neighborhood_by_distance(pos, neighborhood) sorted_spots.reverse() index = 0 while (furthest_empty is None and index < len(sorted_spots)): spot = sorted_spots[index] if self.grid.is_cell_empty(spot) or self.grid[spot[1]][spot[0]].breed == "Palestinian" : furthest_empty = sorted_spots[index] index += 1 return furthest_empty def sort_neighborhood_by_distance(self, from_pos, neighbor_spots): from_x, from_y = from_pos return sorted(neighbor_spots, key = lambda spot: self.eucledean_distance(from_x, spot[0], from_y, spot[1], self.grid.width, self.grid.height)) def eucledean_distance(self, x1,x2,y1,y2,w,h): # http://stackoverflow.com/questions/2123947/calculate-distance-between-two-x-y-coordinates return math.sqrt(min(abs(x1 - x2), w - abs(x1 - x2)) ** 2 + min(abs(y1 - y2), h - abs(y1-y2)) ** 2) def step(self): """ Advance the model by one step and collect data. """ self.violence_count = 0 # for i in range(100): self.schedule.step() self.total_violence += self.violence_count # average = self.violence_count / 100 #print("Violence average %f " % average) print("Total Violence: ", self.total_violence)
class Movement(Model): def __init__(self, width = 0, height = 0, torus = False, time = 0, step_in_year = 0, number_of_families = family_setting, number_of_monkeys = 0, monkey_birth_count = 0, monkey_death_count = 0, monkey_id_count = 0, number_of_humans = 0, grid_type = human_setting, run_type = run_setting, human_id_count = 0): # change the # of families here for graph.py, but use server.py to change # of families in the movement model # torus = False means monkey movement can't 'wrap around' edges super().__init__() self.width = width self.height = height self.time = time # time increases by 1/73 (decimal) each step self.step_in_year = step_in_year # 1-73; each step is 5 days, and 5 * 73 = 365 days in a year self.number_of_families = number_of_families self.number_of_monkeys = number_of_monkeys # total, not in each family self.monkey_birth_count = monkey_birth_count self.monkey_death_count = monkey_death_count self.monkey_id_count = monkey_id_count self.number_of_humans = number_of_humans self.grid_type = grid_type # string 'with_humans' or 'without_humans' self.run_type = run_type # string with 'normal_run' or 'first_run' self.human_id_count = human_id_count # width = self._readASCII(vegetation_file)[1] # width as listed at the beginning of the ASCII file # height = self._readASCII(vegetation_file)[2] # height as listed at the beginning of the ASCII file width = 85 height = 100 self.grid = MultiGrid(width, height, torus) # creates environmental grid, sets schedule # MultiGrid is a Mesa function that sets up the grid; options are between SingleGrid and MultiGrid # MultiGrid allows you to put multiple layers on the grid self.schedule = RandomActivation(self) # Mesa: Random vs. Staged Activation # similar to NetLogo's Ask Agents - determines order (or lack of) in which each agents act empty_masterdict = {'Outside_FNNR': [], 'Elevation_Out_of_Bound': [], 'Household': [], 'PES': [], 'Farm': [], 'Forest': [], 'Bamboo': [], 'Coniferous': [], 'Broadleaf': [], 'Mixed': [], 'Lichen': [], 'Deciduous': [], 'Shrublands': [], 'Clouds': [], 'Farmland': []} # generate land if self.run_type == 'first_run': gridlist = self._readASCII(vegetation_file)[0] # list of all coordinate values; see readASCII function gridlist2 = self._readASCII(elevation_file)[0] # list of all elevation values gridlist3 = self._readASCII(household_file)[0] # list of all household coordinate values gridlist4 = self._readASCII(pes_file)[0] # list of all PES coordinate values gridlist5 = self._readASCII(farm_file)[0] # list of all farm coordinate values gridlist6 = self._readASCII(forest_file)[0] # list of all managed forest coordinate values # The '_populate' function below builds the environmental grid. for x in [Elevation_Out_of_Bound]: self._populate(empty_masterdict, gridlist2, x, width, height) for x in [Household]: self._populate(empty_masterdict, gridlist3, x, width, height) for x in [PES]: self._populate(empty_masterdict, gridlist4, x, width, height) for x in [Farm]: self._populate(empty_masterdict, gridlist5, x, width, height) for x in [Forest]: self._populate(empty_masterdict, gridlist6, x, width, height) for x in [Bamboo, Coniferous, Broadleaf, Mixed, Lichen, Deciduous, Shrublands, Clouds, Farmland, Outside_FNNR]: self._populate(empty_masterdict, gridlist, x, width, height) self.saveLoad(empty_masterdict, 'masterdict_veg', 'save') self.saveLoad(self.grid, 'grid_veg', 'save') self.saveLoad(self.schedule, 'schedule_veg', 'save') # Pickling below load_dict = {} # placeholder for model parameters, leave this here even though it does nothing if self.grid_type == 'with_humans': empty_masterdict = self.saveLoad(load_dict, 'masterdict_veg', 'load') self.grid = self.saveLoad(self.grid, 'grid_veg', 'load') if self.grid_type == 'without_humans': empty_masterdict = self.saveLoad(load_dict, 'masterdict_without_humans', 'load') self.grid = self.saveLoad(load_dict, 'grid_without_humans', 'load') masterdict = empty_masterdict startinglist = masterdict['Broadleaf'] + masterdict['Mixed'] + masterdict['Deciduous'] # Agents will start out in high-probability areas. for coordinate in masterdict['Elevation_Out_of_Bound'] + masterdict['Household'] + masterdict['PES'] \ + masterdict['Farm'] + masterdict['Forest']: if coordinate in startinglist: startinglist.remove(coordinate) # Creation of resources (yellow dots in simulation) # These include Fuelwood, Herbs, Bamboo, etc., but right now resource type and frequency are not used if self.grid_type == 'with_humans': for line in _readCSV('hh_survey.csv')[1:]: # see 'hh_survey.csv' hh_id_match = int(line[0]) resource_name = line[1] # frequency is monthly; currently not-used frequency = float(line[2]) / 6 # divided by 6 for 5-day frequency, as opposed to 30-day (1 month) y = int(line[5]) x = int(line[6]) resource = Resource(_readCSV('hh_survey.csv')[1:].index(line), self, (x, y), hh_id_match, resource_name, frequency) self.grid.place_agent(resource, (int(x), int(y))) resource_dict.setdefault(hh_id_match, []).append(resource) if self.run_type == 'first_run': self.saveLoad(resource_dict, 'resource_dict', 'save') # Creation of land parcels land_parcel_count = 0 # individual land parcels in each household (non-gtgp and gtgp) for line in _readCSV('hh_land.csv')[2:]: # exclude headers; for each household: age_1 = float(line[45]) gender_1 = float(line[46]) education_1 = float(line[47]) hh_id = int(line[0]) hh_size = 0 # calculate later total_rice = float(line[41]) if total_rice in [-2, -3, -4]: total_rice = 0 gtgp_rice = float(line[42]) if gtgp_rice in [-2, -3, -4]: gtgp_rice = 0 total_dry = float(line[43]) if total_dry in [-2, -3, -4]: total_dry = 0 gtgp_dry = float(line[44]) if gtgp_dry in [-2, -3, -4]: gtgp_dry = 0 # non_gtgp_area = float(total_rice) + float(total_dry) - float(gtgp_dry) - float(gtgp_rice) # gtgp_area = float(gtgp_dry) + float(gtgp_rice) for i in range(1, 6): # for each household, which has up to 5 each of possible non-GTGP and GTGP parcels: # non_gtgp_area = float(line[i + 47].replace("\"","")) # gtgp_area = float(line[i + 52].replace("\"","")) non_gtgp_area = float(total_rice) + float(total_dry) - float(gtgp_dry) - float(gtgp_rice) gtgp_area = float(gtgp_dry) + float(gtgp_rice) if gtgp_area in [-2, -3, -4]: gtgp_area = 0 if non_gtgp_area in [-2, -3, -4]: non_gtgp_area = 0 if non_gtgp_area > 0: gtgp_enrolled = 0 non_gtgp_output = float(line[i].replace("\"","")) pre_gtgp_output = 0 land_time = float(line[i + 25].replace("\"","")) # non-gtgp travel time plant_type = float(line[i + 10].replace("\"","")) # non-gtgp plant type land_type = float(line[i + 30].replace("\"","")) # non-gtgp land type if land_type not in [-2, -3, -4]: land_parcel_count += 1 if non_gtgp_output in [-3, '-3', -4, '-4']: non_gtgp_output = 0 if pre_gtgp_output in [-3, '-3', -4, '-4']: pre_gtgp_output = 0 lp = Land(land_parcel_count, self, hh_id, gtgp_enrolled, age_1, gender_1, education_1, gtgp_dry, gtgp_rice, total_dry, total_rice, land_type, land_time, plant_type, non_gtgp_output, pre_gtgp_output, hh_size, non_gtgp_area, gtgp_area) self.schedule.add(lp) if gtgp_area > 0: gtgp_enrolled = 1 pre_gtgp_output = 0 non_gtgp_output = float(line[i].replace("\"","")) land_time = float(line[i + 20].replace("\"","")) # gtgp travel time plant_type = float(line[i + 15].replace("\"","")) # gtgp plant type land_type = float(line[i + 35].replace("\"","")) # gtgp land type if land_type not in [-3, '-3', -4, '-4']: land_parcel_count += 1 if non_gtgp_output in [-3, '-3', -4, '-4']: non_gtgp_output = 0 if pre_gtgp_output in [-3, '-3', -4, '-4']: pre_gtgp_output = 0 lp = Land(land_parcel_count, self, hh_id, gtgp_enrolled, age_1, gender_1, education_1, gtgp_dry, gtgp_rice, total_dry, total_rice, land_type, land_time, plant_type, non_gtgp_output, pre_gtgp_output, hh_size, non_gtgp_area, gtgp_area) self.schedule.add(lp) # Creation of humans (brown dots in simulation) self.number_of_humans = 0 self.human_id_count = 0 line_counter = 0 for line in _readCSV('hh_citizens.csv')[1:]: # exclude headers; for each household: hh_id = int(line[0]) line_counter += 1 starting_position = (int(_readCSV('household.csv')[line_counter][4]), int(_readCSV('household.csv')[line_counter][3])) try: resource = random.choice(resource_dict[str(hh_id)]) # random resource point for human resource_position = resource.position resource_frequency = resource.frequency # to travel to, among the list of resource points reported by that household; may change later # to another randomly-picked resource except KeyError: resource_position = starting_position # some households don't collect resources resource_frequency = 0 hh_gender_list = line[1:10] hh_age_list = line[10:19] hh_education_list = line[19:28] hh_marriage_list = line[28:37] # creation of non-migrants for list_item in hh_age_list: if str(list_item) == '-3' or str(list_item) == '': hh_age_list.remove(list_item) for x in range(len(hh_age_list) - 1): person = [] for item in [hh_age_list, hh_gender_list, hh_education_list, hh_marriage_list]: person.append(item[x]) age = float(person[0]) gender = int(person[1]) education = int(person[2]) marriage = int(person[3]) if marriage != 1: marriage = 6 if 15 < age < 59: work_status = 1 elif 7 < age < 15: work_status = 5 else: work_status = 6 mig_years = 0 migration_network = int(line[37]) income_local_off_farm = int(line[57]) resource_check = 0 mig_remittances = int(line[48]) past_hh_id = hh_id migration_status = 0 death_rate = 0 gtgp_part = 0 non_gtgp_area = 0 if str(gender) == '1': if 0 < age <= 10: age_category = 0 elif 10 < age <= 20: age_category = 1 elif 20 < age <= 30: age_category = 2 elif 30 < age <= 40: age_category = 3 elif 40 < age <= 50: age_category = 4 elif 50 < age <= 60: age_category = 5 elif 60 < age <= 70: age_category = 6 elif 70 < age <= 80: age_category = 7 elif 80 < age <= 90: age_category = 8 elif 90 < age: age_category = 9 elif str(gender) != "1": if 0 < age <= 10: age_category = 10 elif 10 < age <= 20: age_category = 11 elif 20 < age <= 30: age_category = 12 elif 30 < age <= 40: age_category = 13 elif 40 < age <= 50: age_category = 14 elif 50 < age <= 60: age_category = 15 elif 60 < age <= 70: age_category = 16 elif 70 < age <= 80: age_category = 17 elif 80 < age <= 90: age_category = 18 elif 90 < age: age_category = 19 children = 0 if gender == 2: if marriage == 1 and age < 45: children = random.randint(0, 4) # might already have kids birth_plan_chance = random.random() if birth_plan_chance < 0.03125: birth_plan = 0 elif 0.03125 <= birth_plan_chance < 0.1875: birth_plan = 1 elif 0.1875 <= birth_plan_chance < 0.5: birth_plan = 2 elif 0.5 <= birth_plan_chance < 0.8125: birth_plan = 3 elif 0.8125 <= birth_plan_chance < 0.96875: birth_plan = 4 else: birth_plan = 5 elif gender != 2: birth_plan = 0 last_birth_time = random.uniform(0, 1) human_demographic_structure_list[age_category] += 1 if str(person[0]) != '' and str(person[0]) != '-3' and str(person[1]) != '-3': # sorts out all blanks self.number_of_humans += 1 self.human_id_count += 1 human = Human(self.human_id_count, self, starting_position, hh_id, age, # creates human resource_check, starting_position, resource_position, resource_frequency, gender, education, work_status, marriage, past_hh_id, mig_years, migration_status, gtgp_part, non_gtgp_area, migration_network, mig_remittances, income_local_off_farm, last_birth_time, death_rate, age_category, children, birth_plan) if self.grid_type == 'with_humans': self.grid.place_agent(human, starting_position) self.schedule.add(human) # creation of migrant hh_migrants = line[38:43] # age, gender, marriage, education of migrants if str(hh_migrants[0]) != '' and str(hh_migrants[0]) != '-3'\ and str(hh_migrants[1]) != '' and str(hh_migrants[1]) != '-3': # if that household has any migrants, create migrant person self.number_of_humans += 1 self.human_id_count += 1 age = float(hh_migrants[0]) gender = float(hh_migrants[1]) education = int(hh_migrants[2]) marriage = int(hh_migrants[3]) mig_years = int(hh_migrants[4]) if 15 < age < 59: work_status = 1 elif 7 < age < 15: work_status = 5 else: work_status = 6 past_hh_id = hh_id hh_id = 'Migrated' migration_status = 1 migration_network = int(line[37]) last_birth_time = random.uniform(0, 1) total_rice = float(line[43]) gtgp_rice = float(line[44]) total_dry = float(line[45]) gtgp_dry = float(line[46]) income_local_off_farm = float(line[57]) if total_rice in ['-3', '-4', -3, None]: total_rice = 0 if total_dry in ['-3', '-4', -3, None]: total_dry = 0 if gtgp_dry in ['-3', '-4', -3, None]: gtgp_dry = 0 if gtgp_rice in ['-3', '-4', -3, None]: gtgp_rice = 0 if (gtgp_dry + gtgp_rice) != 0: gtgp_part = 1 else: gtgp_part = 0 non_gtgp_area = ((total_rice) + (total_dry)) \ - ((gtgp_dry) + (gtgp_rice)) resource_check = 0 mig_remittances = int(line[48]) death_rate = 0 if gender == 1: # human male (monkeys are 0 and 1, humans are 1 and 2) if 0 < age <= 10: age_category = 0 elif 10 < age <= 20: age_category = 1 elif 20 < age <= 30: age_category = 2 elif 30 < age <= 40: age_category = 3 elif 40 < age <= 50: age_category = 4 elif 50 < age <= 60: age_category = 5 elif 60 < age <= 70: age_category = 6 elif 70 < age <= 80: age_category = 7 elif 80 < age <= 90: age_category = 8 elif 90 < age: age_category = 9 elif gender != 1: if 0 < age <= 10: age_category = 10 elif 10 < age <= 20: age_category = 11 elif 20 < age <= 30: age_category = 12 elif 30 < age <= 40: age_category = 13 elif 40 < age <= 50: age_category = 14 elif 50 < age <= 60: age_category = 15 elif 60 < age <= 70: age_category = 16 elif 70 < age <= 80: age_category = 17 elif 80 < age <= 90: age_category = 18 elif 90 < age: age_category = 19 children = 0 if gender == 2: if marriage == 1 and age < 45: children = random.randint(0, 4) # might already have kids birth_plan_chance = random.random() if birth_plan_chance < 0.03125: birth_plan = 0 elif 0.03125 <= birth_plan_chance < 0.1875: birth_plan = 1 elif 0.1875 <= birth_plan_chance < 0.5: birth_plan = 2 elif 0.5 <= birth_plan_chance < 0.8125: birth_plan = 3 elif 0.8125 <= birth_plan_chance < 0.96875: birth_plan = 4 else: birth_plan = 5 elif gender != 2: birth_plan = 0 human_demographic_structure_list[age_category] += 1 human = Human(self.human_id_count, self, starting_position, hh_id, age, # creates human resource_check, starting_position, resource_position, resource_frequency, gender, education, work_status, marriage, past_hh_id, mig_years, migration_status, gtgp_part, non_gtgp_area, migration_network, mig_remittances, income_local_off_farm, last_birth_time, death_rate, age_category, children, birth_plan) if self.grid_type == 'with_humans': self.grid.place_agent(human, starting_position) self.schedule.add(human) # Creation of monkey families (moving agents in the visualization) for i in range(self.number_of_families): # the following code block creates families starting_position = random.choice(startinglist) saved_position = starting_position from families import Family family_size = random.randint(25, 45) # sets family size for each group--random integer family_id = i list_of_family_members = [] family_type = 'traditional' # as opposed to an all-male subgroup split_flag = 0 # binary: 1 means its members start migrating out to a new family family = Family(family_id, self, starting_position, family_size, list_of_family_members, family_type, saved_position, split_flag) self.grid.place_agent(family, starting_position) self.schedule.add(family) global_family_id_list.append(family_id) # Creation of individual monkeys (not in the visualization submodel, but for the demographic submodel) for monkey_family_member in range(family_size): # creates the amount of monkeys indicated earlier id = self.monkey_id_count gender = random.randint(0, 1) if gender == 1: # gender = 1 is female, gender = 0 is male. this is different than with humans (1 or 2) female_list.append(id) last_birth_interval = random.uniform(0, 2) else: male_maingroup_list.append(id) # as opposed to the all-male subgroup last_birth_interval = -9999 # males will never give birth mother = 0 # no parent check for first generation choice = random.random() # 0 - 1 float - age is determined randomly based on weights if choice <= 0.11: # 11% of starting monkey population age = random.uniform(0, 1) # are randomly aged befween age_category = 0 # ages 0-1 demographic_structure_list[0] += 1 elif 0.11 < choice <= 0.27: # 16% of starting monkey population age = random.uniform(1, 3) # are randomly aged befween age_category = 1 # ages 1-3 demographic_structure_list[1] += 1 elif 0.27 < choice <= 0.42: # 15% of starting monkey population age = random.uniform(3, 7) # are randomly aged between age_category = 2 # ages 3-7 demographic_structure_list[2] += 1 elif 0.42 < choice <= 0.62: # 11% of starting monkey population age = random.uniform(7, 10) # are randomly aged befween age_category = 3 # ages 7-10 demographic_structure_list[3] += 1 elif 0.62 < choice <= 0.96: # 34% of starting monkey population age = random.uniform(10, 25) # are randomly aged befween age_category = 4 # ages 10-25 demographic_structure_list[4] += 1 if gender == 1: if id not in reproductive_female_list: reproductive_female_list.append(id) # starting representation of male defection/gender ratio structure_convert = random.random() if gender == 0: if structure_convert < 0.6: gender = 1 last_birth_interval = random.uniform(0, 3) if id not in reproductive_female_list: reproductive_female_list.append(id) elif 0.96 < choice: # 4% of starting monkey population age = random.uniform(25, 30) # are randomly aged between age_category = 5 # ages 25-30 demographic_structure_list[5] += 1 gender = 1 monkey = Monkey(id, self, gender, age, age_category, family, last_birth_interval, mother ) self.number_of_monkeys += 1 self.monkey_id_count += 1 list_of_family_members.append(monkey.unique_id) self.schedule.add(monkey) def step(self): # necessary; tells model to move forward self.time += (1/73) self.step_in_year += 1 if self.step_in_year > 73: self.step_in_year = 1 # start new year self.schedule.step() def _readASCII(self, text): # reads in a text file that determines the environmental grid setup f = open(text, 'r') body = f.readlines() width = body[0][-4:] # last 4 characters of line that contains the 'width' value height = body[1][-5:] abody = body[6:] # ASCII file with a header f.close() abody = reversed(abody) cells = [] for line in abody: cells.append(line.split(" ")) return [cells, int(width), int(height)] def _populate(self, masterdict, grid, land_type, width, height): # places land tiles on the grid - connects color/land cover category with ASCII file values counter = 0 # sets agent ID - not currently used for y in range(height): # for each pixel, for x in range(width): value = float(grid[y][x]) # value from the ASCII file for that coordinate/pixel, e.g. 1550 elevation land_grid_coordinate = x, y land = land_type(counter, self) if land_type.__name__ == 'Elevation_Out_of_Bound': if (value < land_type.lower_bound or value > land_type.upper_bound) and value != -9999: # if elevation is not 1000-2200, but is within the bounds of the FNNR, mark as 'elevation OOB' self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 elif land_type.__name__ == 'Forest': if land_type.type == value: self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 elif land_type.__name__ == 'PES': if land_type.type == value: self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 elif land_type.__name__ == 'Farm': if land_type.type == value: self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 elif land_type.__name__ == 'Household': if land_type.type == value: self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 else: # vegetation background if land_type.type == value: self.grid.place_agent(land, land_grid_coordinate) masterdict[land.__class__.__name__].append(land_grid_coordinate) counter += 1 def saveLoad(self, pickled_file, name, option): """ This function pickles an object, which lets it be loaded easily later. I haven't figured out how to utilize pickle to pickle class objects (if possible). """ if option == "save": f = open(name, 'wb') pickle.dump(pickled_file, f) f.close() elif option == "load": f = open(name, 'rb') new_pickled_file = pickle.load(f) return new_pickled_file else: print('Invalid saveLoad option')
class DDAModel(Model): """A simple DDA model""" _width = _WIDTH # width and height of the world. These shouldn't be changed _height = _HEIGHT def __init__(self, N, iterations, bleedout_rate=np.random.normal(0.5, scale=0.1), mp=False): """ Create a new instance of the DDA model. Parameters: N - the number of agents iterations - the number of iterations to run the model for blr - the bleedout rate (the probability that agents leave at the midpoint) (default normal distribution with mean=0.5 and sd=0.1) mp - whether to use multiprocess (agents call step() method at same time) (doesn't work!) (default False) """ self.num_agents = N self._bleedout_rate = bleedout_rate self.iterations = iterations self.mp = mp # Locations of important parts of the environment. These shouldn't be changed self.graveyard = (0, 0) # x,y locations of the graveyard self.loc_a = (1, 0) # Location a (on left side of street) self.loc_b = (23, 0) # Location b (on the right side) self.loc_mid = (12, 0) # The midpoint # 'Cameras' that store the number of agents who pass them over the course of an hour. The historical counts # are saved by mesa using the DataCollector self._camera_a = 0 # Camera A self._camera_b = 0 # Camera B self._camera_m = 0 # The midpoint # Set up the scheduler. Note that this isn't actually used (see below re. agent's stepping) self.schedule = RandomActivation(self) # Random order for calling agent's step methods # For multiprocess step method self.pool = Pool() # Create the environment self.grid = MultiGrid(DDAModel._width, DDAModel._height, False) # Define a variable that can be used to indicate whether the model has finished self.running = True # Create a distribution that tells us the number of agents to be added to the world at each self._agent_dist = DDAModel._make_agent_distribution(N) # Create all the agents for i in range(self.num_agents): a = DDAAgent(i, self) self.schedule.add(a) # Add the agents to the schedule # All agents start as 'retired' in the graveyard a.state = AgentStates.RETIRED self.grid.place_agent(a, self.graveyard) # All agents start in the graveyard print("Created {} agents".format(len(self.schedule.agents))) # Define a collector for model data self.datacollector = DataCollector( model_reporters={"Bleedout rate": lambda m: m.bleedout_rate, "Number of active agents": lambda m: len(m.active_agents()), "Camera A counts": lambda m: m.camera_a, "Camera B counts": lambda m: m.camera_b, "Camera M counts": lambda m: m.camera_m }, agent_reporters={"Location (x)": lambda agent: agent.pos[0], "State": lambda agent: agent.state } ) def step(self): """Advance the model by one step.""" print("Iteration {}".format(self.schedule.steps)) self.datacollector.collect(self) # Collect data about the model # See if the model has finished running. if self.schedule.steps >= self.iterations: self.running = False return # Things to do every hour. # - 1 - reset the camera counters # - 2 - activate some agents num_to_activate = -1 s = self.schedule.steps # Number of steps (for convenience) if s % 60 == 0: # On the hour # Reset the cameras self._reset_cameras() # Calculate the number of agents to activate num_to_activate = int(self._agent_dist[int((s / 60) % 24)]) print("\tActivating {} agents on hour {}".format(num_to_activate, s % 60)) else: num_to_activate = 0 assert num_to_activate >= 0, \ "The number of agents to activate should be greater or equal to 0, not {}".format(num_to_activate) if num_to_activate > 0: # Choose some agents that are currently retired to activate. retired_agents = [a for a in self.schedule.agents if a.state == AgentStates.RETIRED] assert len(retired_agents) >= num_to_activate, \ "Too few agents to activate (have {}, need {})".format(len(retired_agents), num_to_activate) to_activate = np.random.choice(retired_agents, size=num_to_activate, replace=False) print("\t\tActivating agents: {}".format(to_activate)) for a in to_activate: a.activate() # XXXX HERE - see line 477 om wprlomgca,eras/py # Call all agents' 'step' method. if not self.mp: # Not using multiprocess. Do it the mesa way: self.schedule.step() else: # Better to do it a different way to take advantage of multicore processors and to ignore agents who are not # active (no need for them to step at all) # NOTE: Doesn't work! The problem is that the DDAAgent needs the DDAModel class, which means # that this class needs to be pickled and copied to the child processes. The first problem (which can be # fixed by creating functions rather than using lambda, although this is messy) is that DDAModel uses # lambda functions, that can't be pickled. Second and more difficult problem is that the Pool object itself # cannot be shared. Possible solution here: # https://stackoverflow.com/questions/25382455/python-notimplementederror-pool-objects-cannot-be-passed-between-processes # but for the meantime I'm not going to try to fix this. active_agents = self.active_agents() # Get all of the active agents random.shuffle(active_agents) if active_agents is None: print("\tNo agents are active") # Nothing to do else: p = Pool() p.map(DDAAgent._step_agent, active_agents) # Calls step() for all agents # As not using the proper schedule method, need to update time manually. self.schedule.steps += 1 self.schedule.time += 1 def increment_camera_a(self): """Used by agents to tell the model that they have just passed the camera at location A. It would be neater to have the cameras detect the agents, but I think that this would be quite expensive.""" self._camera_a += 1 # Increment the count of the current hour (most recent) def increment_camera_b(self): """Used by agents to tell the model that they have just passed the camera at location B. It would be neater to have the cameras detect the agents, but I think that this would be quite expensive.""" self._camera_b += 1 # Increment the count of the current hour (most recent) def increment_camera_m(self): """Used by agents to tell the model that they have just passed the camera at the midpoint. This is only for information really, in this scenario there is no camera at the midpoint""" self._camera_m += 1 # Increment the count of the current hour (most recent) @property def camera_a(self) -> int: """Getter for the count of the camera at location A""" return self._camera_a @property def camera_b(self) -> int: """Getter for the count of the camera at location B""" return self._camera_b @property def camera_m(self) -> int: """Getter for the count of the camera at the midpoint""" return self._camera_m def _reset_cameras(self): """Reset the cameras to zero. Done on the hour""" self._camera_a = 0 self._camera_b = 0 self._camera_m = 0 @staticmethod def _step_agent(a): """Call the given agent's step method. Only required because Pool.map doesn't take lambda functions.""" a.step() # bleedout rate is defined as a property: http://www.python-course.eu/python3_properties.php @property def bleedout_rate(self): """Get the current bleedout rate""" return self._bleedout_rate @bleedout_rate.setter def bleedout_rate(self, blr: float) -> None: """Set the bleedout rate. It must be between 0 and 1 (inclusive). Failure to do that raises a ValueError.""" if blr < 0 or blr > 1: raise ValueError("The bleedout rate must be between 0 and 1, not '{}'".format(blr)) self._bleedout_rate = blr def active_agents(self) -> List[DDAAgent]: """Return a list of the active agents (i.e. those who are not retired)""" return [a for a in self.schedule.agents if a.state != AgentStates.RETIRED] @classmethod def _make_agent_distribution(cls, N): """Create a distribution that tells us the number of agents to be created at each hour""" a = np.arange(0, 24, 1) # Create an array with one item for each hour rv1 = norm(loc=12., scale=6.0) # A continuous, normal random variable with a peak at 12 dist = rv1.pdf(a) # Draw from the random variable pdf, taking values from a return [round(item * N, ndigits=0) for item in dist] # Return a rounded list (the number of agents at each hour)