def launch_basic():
width = 15
height = 10
num_agents = 2
pixel_ratio = 50
grid = CanvasGrid(agent_draw, width, height, width * pixel_ratio, height * pixel_ratio)
server = ModularServer(ShapesModel, [grid], "Basic Example", num_agents, width, height)
server.max_steps = 0
server.port = 8888
server.launch()
def launch_shape_model():
width = 15
height = 10
num_agents = 2
pixel_ratio = 50
grid = CanvasGrid(agent_draw, width, height,
width * pixel_ratio, height * pixel_ratio)
server = ModularServer(ShapeExample, [grid], "Shape Model Example",
{"N": num_agents, "width": width, "height": height})
server.max_steps = 0
server.port = 8521
server.launch()
class TestModularServer(TestCase):
""" Test server for testing """
def portrayal(self, cell):
return {
"Shape": "rect",
"w": 1,
"h": 1,
"Filled": "true",
"Layer": 0,
"x": 0,
"y": 0,
"Color": "black"
}
def setUp(self):
self.user_params = {
'width': 1,
'height': 1,
'key1': UserSettableParameter('number', "Test Parameter", 101),
'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10)
}
self.viz_elements = [
CanvasGrid(self.portrayal, 10, 10, 20, 20),
TextElement(),
# ChartModule([{"Label": "Wolves", "Color": "#AA0000"}, # Todo - test chart module
# {"Label": "Sheep", "Color": "#666666"}])
]
self.server = ModularServer(MockModel, self.viz_elements, "Test Model", model_params=self.user_params)
def test_canvas_render_model_state(self):
test_portrayal = self.portrayal(None)
test_grid_state = defaultdict(list)
test_grid_state[test_portrayal['Layer']].append(test_portrayal)
state = self.server.render_model()
assert state[0] == test_grid_state
def test_text_render_model_state(self):
state = self.server.render_model()
assert state[1] == '<b>VisualizationElement goes here</b>.'
def test_user_params(self):
print(self.server.user_params)
assert self.server.user_params == {
'key1': UserSettableParameter('number', "Test Parameter", 101).json,
'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10).json
}
def main(x_size, y_size):
""" This function sets up a canvas to graphically represent the model 'MoneyModel'
and a chart, than it runs the server and runs the model in model.py in the browser """
grid = CanvasGrid(agent_portrayal, x_size, y_size, 500, 500)
chart = ChartModule([{"Label": "Gini",
"Color": "Black"}],
data_collector_name='datacollector')
# the simulation uses a class DataCollector, that collects the data and
# relays it from self.datacollector to the webpage
server = ModularServer(MoneyModel,
[grid, chart],
"abcEconomics and MESA integrated",
x_size * y_size, x_size, y_size)
server.port = 8534 # change this number if address is in use
server.launch()
def setUp(self):
self.user_params = {
'width': 1,
'height': 1,
'key1': UserSettableParameter('number', "Test Parameter", 101),
'key2': UserSettableParameter('slider', "Test Parameter", 200, 0, 300, 10)
}
self.viz_elements = [
CanvasGrid(self.portrayal, 10, 10, 20, 20),
TextElement(),
# ChartModule([{"Label": "Wolves", "Color": "#AA0000"}, # Todo - test chart module
# {"Label": "Sheep", "Color": "#666666"}])
]
self.server = ModularServer(MockModel, self.viz_elements, "Test Model", model_params=self.user_params)
from mesa.visualization.modules import CanvasGrid
from mesa.visualization.modules import ChartModule
from mesa.visualization.ModularVisualization import ModularServer
from MoneyModel import MoneyModel
def agent_portrayal(agent):
portrayal = {"Shape": "circle",
"Filled": "true",
"r": 0.5}
if agent.wealth > 0:
portrayal["Color"] = "red"
portrayal["Layer"] = 0
else:
portrayal["Color"] = "grey"
portrayal["Layer"] = 1
portrayal["r"] = 0.2
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500)
chart = ChartModule([
{"Label": "Gini", "Color": "Black"}],
data_collector_name='datacollector'
)
server = ModularServer(MoneyModel, [grid, chart], "Money Model", 100, 10, 10)
server.port = 8888
server.launch()
portrayal["Layer"] = 2
portrayal["Shape"] = "rect"
elif type(agent) is IsraelRear:
color = ISRAEL_REAR_COLOR
portrayal["Color"] = color
size = 1.0
portrayal["r"] = portrayal["w"] = portrayal["h"] = size
portrayal["Layer"] = 3
portrayal["Shape"] = "rect"
return portrayal
canvas_element = SeparationBarrierGrid(israeli_palestinian_portrayl, 40, 40, 600, 600)
greed = 4
server = ModularServer(SeparationBarrierModel, [canvas_element],
"Separation Barrier - Greed Level %d" % (greed),
height=40,
width=40,
settlement_density = 0.3,
palestinian_density = 0.2,
settlers_violence_rate = 0.01,
settler_vision = 5,
palestinian_vision = 5,
settlers_growth_rate = 0.01,
suicide_rate = 0.001,
greed_level=greed,
)
server.port = 6666
server.launch()
from mesa.visualization.UserParam import UserSettableParameter
from .model import ForestFire
COLORS = {"Fine": "#00AA00",
"On Fire": "#880000",
"Burned Out": "#000000"}
def forest_fire_portrayal(tree):
if tree is None:
return
portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0}
(x, y) = tree.get_pos()
portrayal["x"] = x
portrayal["y"] = y
portrayal["Color"] = COLORS[tree.condition]
return portrayal
canvas_element = CanvasGrid(forest_fire_portrayal, 100, 100, 500, 500)
tree_chart = ChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()])
pie_chart = PieChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()])
model_params = {
"height": 100,
"width": 100,
"density": UserSettableParameter("slider", "Tree density", 0.65, 0.01, 1.0, 0.01)
}
server = ModularServer(ForestFire, [canvas_element, tree_chart, pie_chart], "Forest Fire", model_params)
elif agent.type == "exploiter":
return {
"Shape": "circle",
"Filled": "true",
"Layer": 0.2,
"Color": "red",
"r": 0.5,
}
else:
return {
"Shape": "rect",
"Filled": "true",
"Layer": 0,
"Color": "green",
"w": 1,
"h": 1,
}
grid = CanvasGrid(agent_portrayal, 100, 100, 800, 800)
chart = ChartModule([{
"Label": "Num_Explorer",
"Color": "Black"
}, {
"Label": "Num_Exploiter",
"Color": "Red"
}],
data_collector_name='datacollector')
server = ModularServer(World, [grid, chart], "Demo", {"N": 100, "coop": 0.5})
# server = ModularServer(World, [grid], "Demo", {"N": 100, "coop": 0.5})
10,
description='Cost of screening for COVID-19'),
'hospitalization_cost':
UserSettableParameter(
'slider',
'Hospitalization Cost',
30000,
1000,
90000,
1000,
description=
'Cost of Hospitalization in the case of severe or critical conditions')
}
server = ModularServer(InfectionModel,
[network, MyTextElement(), chart],
'COVID-19 ABM Economic Evaluation Model', model_params)
server.port = 8521
server.launch()
# def get_column_data(model):
# """pivot the model dataframe to get states count at each step"""
# agent_state = model.datacollector.get_agent_vars_dataframe()
# X = pd.pivot_table(agent_state.reset_index(),index='Step',columns='State',aggfunc=np.size,fill_value=0)
# labels = ['Susceptible','Infected','Removed']
# X.columns = labels[:len(X.columns)]
# return X
# def plot_states_bokeh(model,title=''):
# """Plot cases per country"""
chart_smart = ChartModule([{
"Label": "SmartMedicine",
"Color": "black"
}],
data_collector_name='datacollector')
chart_rad = ChartModule([{
"Label": "RadoznalostSum",
"Color": "black"
}],
data_collector_name='datacollector')
server = ModularServer(
CancerModel, [grid, chart, chart_speed, chart_smart, chart_rad],
"Cancer Model", {
"cancer_cells_number": KOLICINA_CELIJA,
"cure_number": BROJ_LEKOVA,
"eat_values": eat_values,
"verovatnoca_mutacije": VEROVATNOCA_MUTACIJE
})
server.port = 8523
server.launch()
#1. popunjavamo sve delove sa healthy cells check_input
#2. implementiramo brzine, random choice brzine
#### lista brzina i onda svaki agent kojeg stavljamo ima random brzinu
#### mislim da je to ok svakako cemo do nekog balansa doci
# sad treba da mutiramo i eliminiramo u svakom koraku
#znaci u steps bude da se izracuna ta fitness funkcija, a ko proguta otrov ce dobiti nagradu
# za sada cemo samo ubijati npr 5% najgorih tj. 5% najboljih cemo umnoziti
model_type = RPSModel
model_labels = [{
"Label": "Rock",
"Color": "red"
}, {
"Label": "Paper",
"Color": "green"
}, {
"Label": "Scissors",
"Color": "blue"
}]
model_visualisation = [
grid,
chart_populations(model_labels),
chart_scores(model_labels),
evolving_agents()
]
if model_config['probability_mutation'] > 0:
model_visualisation.append(mutating_agents())
server = ModularServer(model_cls=model_type,
visualization_elements=model_visualisation,
name=model_name,
model_params={"config": model_config})
server.verbose = False
logger.critical("Started server.")
def agent_portrayal(agent):
portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5}
if agent.wealth > 0:
portrayal["Color"] = "red"
portrayal["Layer"] = 0
else:
portrayal["Color"] = "grey"
portrayal["Layer"] = 1
portrayal["r"] = 0.2
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500)
chart = ChartModule([{
"Label": "Gini",
"Color": "Black"
}],
data_collector_name='datacollector')
server = ModularServer(MoneyModel, [grid, chart], "Money Model", {
"N": 50,
"width": 10,
"height": 10
})
server.port = 8521 # The default
server.launch()
class WealthTable(TextElement):
'''
Display a text count of how many happy agents there are.
'''
def __init__(self):
super().__init__()
def render(self, model):
result = tabulate([[i, v.wealth]
for i, v in enumerate(model.schedule.agents)])
return result
score_table = ScoreTable()
wealth_table = WealthTable()
server = ModularServer(MoneyModel, [
grid,
chart,
price_chart,
participation_chart,
wealth_chart,
max_score_chart,
fluctuation_chart,
producer_pie_chart,
strategy_pie_chart,
speculator_pie_chart,
], "Minority game with producers and speculators", model_params)
server.port = 8521
server.launch()
"viral_load_probability": viral_load_probability,
"behavioral_factors_lbl": UserSettableParameter('static_text', value = "Behavioral Factors"),
"wearing_masks": wearing_masks,
"social_distance_limit": social_distance_limit,
"health_factors_lbl": UserSettableParameter('static_text', value = "Health Factors"),
"natural_immunity": natural_immunity,
"exercise": exercise,
"preexisting_conditions": preexisting_conditions,
"policy_lbl": UserSettableParameter('static_text', value = "Policy Restrictions"),
"minority_restrictions": minority_restrictions,
"adult_restrictions": adult_restrictions,
}
components = [
total_cases_element,
active_cases_element,
recovered_element,
canvas_element,
summary_element,
summary_chart,
infected_chart
]
server = ModularServer(
SimulationEnvironment, components, "COVID19 Agent Based Model with Multi-Objective Optimization for Vaccine Distribution", model_params
)
server.port = PORT
# server.py
from mesa.visualization.modules import CanvasGrid
from mesa.visualization.ModularVisualization import ModularServer
from intro import MoneyModel
def agent_portrayal(agent):
portrayal = {"Shape": "circle",
"Filled": "true",
"Layer": 0,
"Color": "red",
"r": 0.5}
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500)
server = ModularServer(MoneyModel,
[grid],
"Money Model",
{"N": 100, "width": 10, "height": 10})
server.port = 8521
server.launch()
value="Random",
choices=["Random", "Neighborhood", "Clusters"]),
"mobility_speed":
UserSettableParameter("choice",
"Mobility",
value="low",
choices=["test", "low", "high"]),
"weeks_to_second_release":
UserSettableParameter("choice",
"Weeks til second release",
value=4,
choices=[2, 4, 6, 8])
}
if model_params["grid_area"].value == "Demo":
grid_height = md.GRID_HEIGHT_DEMO
grid_width = md.GRID_WIDTH_DEMO
elif model_params["grid_area"].value == "Small":
grid_height = md.GRID_HEIGHT_SMALL
grid_width = md.GRID_WIDTH_SMALL
elif model_params["grid_area"].value == "Large":
grid_height = md.GRID_HEIGHT_LARGE
grid_width = md.GRID_WIDTH_LARGE
canvas_element = CanvasGrid(virus_draw, grid_height, grid_width, 500, 500)
server = ModularServer(Virus, [
canvas_element, agent_count_element, susceptible_element, exposed_element,
infectious_element, recovered_element, dead_element, chart
], "Team Virus: COVID-19", model_params)
from mesa.visualization.modules import CanvasGrid, ChartModule
from mesa.visualization.ModularVisualization import ModularServer
from mesa.visualization.UserParam import UserSettableParameter
from Models.PluralityModel import PluralityModel
from Models.InstantRunoffModel import InstantRunoffModel
from Models.PrefrenceModel import PrefrenceModel
from Portrayals.AgentPortrayel import agent_portrayal
from Modules.HistogramModule import HistogramModule
# Interactive visulization
grid = CanvasGrid(agent_portrayal, 100, 100, 500, 500)
histogram = HistogramModule(list(range(10)), 200, 500)
params = {
"n_partys": UserSettableParameter("slider", "Party's Amount", 10, 3, 10),
"n_voters": UserSettableParameter("slider", "Voters Amount", 1000, 10,
9990)
}
server = ModularServer(PrefrenceModel, [grid, histogram],
'Prefrence Model',
model_params=params)
agents[0].wealth),
}
for (node_id, agents) in G.nodes.data('agent')]
portrayal['edges'] = [{'id': edge_id,
'source': source,
'target': target,
'color': '#000000',
}
for edge_id, (source, target) in enumerate(G.edges)]
return portrayal
grid = NetworkModule(network_portrayal, 500, 500, library='sigma')
chart = ChartModule([
{"Label": "Gini", "Color": "Black"}],
data_collector_name='datacollector'
)
model_params = {
"num_agents": UserSettableParameter('slider', "Number of agents", 7, 2, 10, 1,
description="Choose how many agents to include in the model"),
"num_nodes": UserSettableParameter('slider', "Number of nodes", 10, 3, 12, 1,
description="Choose how many nodes to include in the model, with at "
"least the same number of agents")
}
server = ModularServer(BoltzmannWealthModelNetwork, [grid, chart], "Money Model", model_params)
server.port = 8521
0.4,
0.0,
1.0,
0.1,
description='Frequency the nodes check whether they are infected by '
'a virus'),
'recovery_chance':
UserSettableParameter(
'slider',
'Recovery Chance',
0.3,
0.0,
1.0,
0.1,
description='Probability that the virus will be removed'),
'gain_resistance_chance':
UserSettableParameter(
'slider',
'Gain Resistance Chance',
0.5,
0.0,
1.0,
0.1,
description='Probability that a recovered agent will become '
'resistant to this virus in the future'),
}
server = ModularServer(VirusModel, [network, MyTextElement(), chart],
'Virus Model', model_params)
server.port = 8521
portrayal["text"] = round(agent.energy, 1)
portrayal["text_color"] = "White"
elif type(agent) is GrassPatch:
if agent.fully_grown:
portrayal["Color"] = "#00AA00"
else:
portrayal["Color"] = "#D6F5D6"
portrayal["Shape"] = "rect"
portrayal["Filled"] = "true"
portrayal["Layer"] = 0
portrayal["w"] = 1
portrayal["h"] = 1
return portrayal
canvas_element = CanvasGrid(wolf_sheep_portrayal, 20, 20, 500, 500)
chart_element = ChartModule([{
"Label": "Wolves",
"Color": "#AA0000"
}, {
"Label": "Sheep",
"Color": "#666666"
}])
server = ModularServer(WolfSheepPredation, [canvas_element, chart_element],
"WolfSheep",
grass=True)
# server.launch()
from mesa.visualization.modules import CanvasGrid
from mesa.visualization.modules import ChartModule
from mesa.visualization.ModularVisualization import ModularServer
from money_model import MoneyModel
def agent_portrayal(agent):
portrayal = {"Shape": "circle",
"Filled": "true",
"r": 0.5}
if agent.wealth > 0:
portrayal["Color"] = "red"
portrayal["Layer"] = 0
else:
portrayal["Color"] = "grey"
portrayal["Layer"] = 1
portrayal["r"] = 0.2
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500)
chart = ChartModule([
{"Label": "Gini", "Color": "Black"}],
data_collector_name='datacollector'
)
server = ModularServer(MoneyModel, [grid, chart], "Money Model", 100, 10, 10)
server.port = 8521
server.launch()
from model_randomWalk import *
from mesa.visualization.modules import CanvasGrid
from mesa.visualization.ModularVisualization import ModularServer
def agent_portrayal(agent):
portrayal = {
"Shape": "circle",
"Filled": "true",
"Layer": 0,
"Color": "red",
"r": 0.5
}
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 10, 500, 500)
server = ModularServer(RWModel, [grid], "Money Model", {})
server.port = 8522 # The default
server.launch()
from ForestFireFire import ForestFireModel
def agent_portrayal(agent):
portrayal = {"Shape": "rect", "Filled": "true", "w": 1, "h": 1}
if agent.status == "burning":
portrayal["Color"] = "red"
portrayal["Layer"] = 0
elif agent.status == "occupied":
portrayal["Color"] = "green"
portrayal["Layer"] = 1
elif agent.status == "empty":
portrayal["Color"] = "black"
portrayal["Layer"] = 2
return portrayal
L = 10
p = 0.6
grid = CanvasGrid(agent_portrayal, L, L, 500, 500)
server = ModularServer(ForestFireModel, [grid], "Forest Fire Model", {
"L": L,
"p": p
})
server.port = 8521 # The default
server.launch()
data_collector_name="datacollector")
wage_households_sum_chart = ChartModule([{"Label" : "sum_wage",
"Color": "Green"}],
data_collector_name="datacollector")
kapital_firm_chart = ChartModule([{"Label" : "KapitalF",
"Color": "Red"}],
data_collector_name="datacollector")
kapital_bank_chart = ChartModule([{"Label" : "KapitalB",
"Color": "Blue"}],
data_collector_name="datacollector")
diff1 = ChartModule([{"Label" : "diff",
"Color": "Blue"}],
data_collector_name="datacollector")
server = ModularServer(BtcModel,
[kapital_households_chart, kapital_households_global_chart ,kapital_households_risk_averse_chart, kapital_households_speculator_chart],
"Btc Model",
{"n_households":20, "df3": 'pfebtc.xlsx'})
#server2 = ModularServer(SinuModel,
#[kapital_households_global_chart],
#"SinuModel",
#{"n_households":20, "df3": 'pfebtc.xlsx', "list_kapital_global": server.kapital_global_btcModel})
#server.port = 8523 #The default
#server.launch()
'''
if agent is None:
return
portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0}
if agent.a_type == 0:
portrayal["Color"] = "Red"
elif agent.a_type == 1:
portrayal["Color"] = "Blue"
elif agent.a_type == 2:
portrayal["Color"] = "Green"
elif agent.a_type == 3:
portrayal["Color"] = "Yellow"
elif agent.a_type == 4:
portrayal["Color"] = "Orange"
elif agent.a_type == 5:
portrayal["Color"] = "Purple"
elif agent.a_type == 6:
portrayal["Color"] = "Black"
elif agent.a_type == 7:
portrayal["Color"] = "Brown"
return portrayal
happy_element = HappyElement()
canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500)
happy_chart = ChartModule([{"Label": "happy", "Color": "Black"}])
server = ModularServer(SchellingModel,
[canvas_element, happy_element, happy_chart],
"Schelling", 50, 50, 0.8, [.6, .2, .2])
server.launch()
from mesa.visualization.ModularVisualization import ModularServer
from .model import BoidModel
from .SimpleContinuousModule import SimpleCanvas
def boid_draw(agent):
return {"Shape": "circle", "r": 2, "Filled": "true", "Color": "Red"}
boid_canvas = SimpleCanvas(boid_draw, 500, 500)
model_params = {
"N": 100,
"width": 100,
"height": 100,
"speed": 5,
"vision": 10,
"separation": 2
}
server = ModularServer(BoidModel, [boid_canvas], "Boids", model_params)
"Label": "Gini",
"Color": "Black"
}],
data_collector_name='datacollector')
model_params = {
"num_agents":
UserSettableParameter(
'slider',
"Number of agents",
7,
2,
10,
1,
description="Choose how many agents to include in the model"),
"num_nodes":
UserSettableParameter(
'slider',
"Number of nodes",
10,
3,
12,
1,
description="Choose how many nodes to include in the model, with at "
"least the same number of agents")
}
server = ModularServer(BoltzmannWealthModelNetwork, [grid, chart],
"Money Model", model_params)
server.port = 8521
"Filled": "true"
}
if type(agent) is Citizen:
color = AGENT_QUIET_COLOR if agent.condition == "Quiescent" else \
AGENT_REBEL_COLOR
color = JAIL_COLOR if agent.jail_sentence else color
portrayal["Color"] = color
portrayal["r"] = 0.8
portrayal["Layer"] = 0
elif type(agent) is Cop:
portrayal["Color"] = COP_COLOR
portrayal["r"] = 0.5
portrayal["Layer"] = 1
return portrayal
model_params = dict(height=40,
width=40,
citizen_density=.7,
cop_density=.074,
citizen_vision=7,
cop_vision=7,
legitimacy=.8,
max_jail_term=1000)
canvas_element = CanvasGrid(citizen_cop_portrayal, 40, 40, 480, 480)
server = ModularServer(EpsteinCivilViolence, [canvas_element],
"Epstein Civil Violence", model_params)
for (x, y) in product(range(self.grid.width), range(self.grid.height)):
if self.grid[x][y]:
a = list(self.grid[x][y])[0]
if a.die:
self.grid.remove_agent(a)
self.schedule.remove(a)
for na in new_agents:
self.i += 1
a = ConwayAgent(self.i, self)
self.grid.place_agent(a, na)
self.schedule.add(a)
def agent_portrayal(agent):
portrayal = {"Shape": "circle",
"Filled": "true",
"Layer": 0,
"Color": "red",
"r": 0.5}
return portrayal
grid = CanvasGrid(agent_portrayal, 100, 100, 500, 500)
server = ModularServer(ConveyModel,
[grid],
"Convey Model",
{"N": 2000, "width": 100, "height": 100})
server.port = 8521 # The default
server.launch()
'target': target,
'color': '#000000',
} for i, (source, target, _) in enumerate(G.edges(data=True))]
return portrayal
grid = NetworkModule(network_portrayal, 500, 500, library='sigma')
# chart = ChartModule([
# {"Label": "Gini", "Color": "Black"}],
# data_collector_name='datacollector'
# )
model_params = {
"num_agents":
UserSettableParameter(
'slider',
"Number of agents",
7,
2,
50,
1,
description="Choose how many agents to include in the model"),
# "num_nodes": UserSettableParameter('slider', "Number of nodes", 10, 3, 12, 1,
# description="Choose how many nodes to include in the model, with at "
# "least the same number of agents")
}
server = ModularServer(MoneyModel, [grid], "Money Model", model_params)
server.port = 8521
def schelling_draw(agent):
'''
Portrayal Method for canvas
'''
if agent is None:
return
portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0}
if agent.type == 0:
portrayal["Color"] = "Red"
else:
portrayal["Color"] = "Blue"
return portrayal
happy_element = HappyElement()
canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500)
happy_chart = ChartModule([{"Label": "happy", "Color": "Black"}])
model_params = {
"height": 20,
"width": 20,
"density": UserSettableParameter("slider", "Agent density", 0.8, 0.1, 1.0, 0.1),
"minority_pc": UserSettableParameter("slider", "Fraction minority", 0.2, 0.00, 1.0, 0.05),
"homophily": UserSettableParameter("slider", "Homophily", 3, 0, 8, 1)
}
server = ModularServer(SchellingModel,
[canvas_element, happy_element, happy_chart],
"Schelling", model_params)
server.launch()
parameters = json.load(open(config_file))
height = parameters["height"]
width = parameters["width"]
def eco_model_portrayal(patch):
if patch is None:
return
portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0}
(x, y) = patch.get_pos()
portrayal["x"] = x
portrayal["y"] = y
portrayal["Color"] = COLORS[patch.condition]
return portrayal
# add sliders
b_slider = UserSettableParameter('slider', "Establishment probability (b)", 0, 0, 1, 0.01)
m_slider = UserSettableParameter('slider', "Mortality probability vegetated sites (m)", 0, 0.005, 1, 0.001)
canvas_element = CanvasGrid(eco_model_portrayal, height, width, 500, 500)
patch_chart = ChartModule([{"Label": label, "Color": color} for (label, color) in COLORS.items()])
model_params = {
"b": b_slider,
"m": m_slider,
"config_file": config_file
}
server = ModularServer(EcoModel, [canvas_element, patch_chart], "Ecosystem Dynamics", model_params)
# Instantiate canvas grid with width and height in cells/pixels
grid = CanvasGrid(agent_portrayal, width, height, arena_size, arena_size)
# Create a chart for the total amount of chemical
chart1 = ChartModule([{
"Label": "Total_Chem",
"Color": "Black"
}],
data_collector_name='datacollector')
chart2 = ChartModule([{
"Label": "Average_Distance",
"Color": "Red"
}],
data_collector_name='datacollector')
# Create and launch the server
server = ModularServer(
SlimeModel, # the model to feed in
[grid, chart1, chart2], # the list of objects to include in the viz
"Slime Model", # title
{
"pop": slime_population,
"width": width,
"height": height
}) # arguments for the model
server.port = 8251 # the default port
server.launch()
def server_instance(): canvas_element = CanvasGrid(element_portrayal, args["width"], args["height"], args["width"]*10, args["height"]*10) return ModularServer(ProtestModel, [canvas_element], "UCT Protests", **args)
else:
portrayal["Color"] = "#e5f5e0"
if type(agent) is Shrub:
portrayal["Shape"] = "circle"
portrayal["r"] = 0.8
portrayal["Layer"] = 1
if agent.biomass > 0.6:
portrayal["Color"] = "#6E2C00"
elif agent.biomass > 0.3:
portrayal["Color"] = "#DC7633"
else:
portrayal["Color"] = "#EDBB99"
if type(agent) is Grazers:
portrayal["Shape"] = "circle"
portrayal["Color"] = "#AA0000"
portrayal["r"] = 0.5
portrayal["Layer"] = 2
portrayal["text"] = agent.unique_id
portrayal["text_color"] = "Yellow"
return portrayal
canvas_element = CanvasGrid(grazer_portrayal, width, height, canvas_width=500, canvas_height=500)
chart_element = ChartModule([{"Label": "Grass biomass", "Color": "#31a354"},
{"Label": "Shrub biomass", "Color": "#6E2C00"}])
model_param = {"width": width, "height": height, "num_grazer": 10, "dens_grass": 0.35}
server = ModularServer(GrAM, [canvas_element, chart_element], "GrAM", model_param)
server.launch()
CANVAS_WIDTH = GRID_COLS * CELL_SIZE
def color_patch_draw(cell):
'''
This function is registered with the visualization server to be called
each tick to indicate how to draw the cell in its current state.
:param cell: the cell in the simulation
:return: the portrayal dictionary.
'''
assert cell is not None
portrayal = {"Shape": "rect", "w": 1, "h": 1, "Filled": "true", "Layer": 0}
portrayal["x"] = cell.get_col()
portrayal["y"] = cell.get_row()
portrayal["Color"] = _COLORS[cell.get_state()]
return portrayal
CANVAS_ELEMENT = CanvasGrid(color_patch_draw,
GRID_COLS, GRID_ROWS,
CANVAS_HEIGHT, CANVAS_WIDTH)
SERVER = ModularServer(ColorPatchModel,
[CANVAS_ELEMENT], "Color Patches",
GRID_ROWS, GRID_COLS)
SERVER.launch()
def agent_portrayal(agent):
portrayal = {"Shape": "circle", "Filled": "true", "r": 0.5}
if agent.reserve > 5:
portrayal["Color"] = "red"
portrayal["Layer"] = 0
else:
portrayal["Color"] = "grey"
portrayal["Layer"] = 1
portrayal["r"] = 0.2
return portrayal
grid = CanvasGrid(agent_portrayal, 10, 11, 500, 500)
chart = ChartModule([{
"Label": "gini",
"Color": "Black"
}],
data_collector_name='dc')
server = ModularServer(ForageModel, [grid, chart],
name="OysterCatcher Model",
model_params={
"n_agents": 15,
"width": 10,
"height": 11
})
server.launch()
from mesa.visualization.ModularVisualization import ModularServer
from congestion import CampusModel
from SimpleContinuousModule import SimpleCanvas
def student_draw(agent):
portrayal = {
"Shape": "circle",
"Color": "red",
"Filled": "true",
"Layer": 0,
"r": 0.5
}
return portrayal
campus_canvas = SimpleCanvas(student_draw, 500, 500)
model_params = {"N": 12, "width": 50, "height": 50}
server = ModularServer(CampusModel, [campus_canvas], "Campus Congestion",
model_params)
# portrayal['Color'] = sugar_color[0]
if agent.pollution > 80:
portrayal['Color'] = 'Black'
elif agent.pollution > 35:
portrayal['Color'] = 'Red'
elif agent.pollution > 18:
portrayal['Color'] = 'DarkOrange'
elif agent.pollution > 5:
portrayal['Color'] = 'Orange'
elif agent.pollution > 0:
portrayal['Color'] = 'Yellow'
else:
portrayal['Color'] = 'White'
if type(agent) is ScapeAgent:
portrayal = {'Shape':'circle', 'r':.7, 'Filled':'true', 'Layer':1}
# log(round(agent.wealth),round(model.total_wealth))
if agent.wealth <= 0:
portrayal['Color'] = 'Red'
else:
portrayal['Color'] = 'Green'
return portrayal
if __name__=='__main__':
canvas_element = CanvasGrid(scape_draw, 50, 50, 800, 800)
total_wealth = ChartModule([{'Label':'Wealth', 'Color':'Blue'}])
agent_count = ChartModule([{'Label':'Agents', 'Color': 'Blue'}])
server = ModularServer(SugarscapeModel, [canvas_element, total_wealth], 'Sugarscape')
server.launch()
if type(agent) is Bean:
portrayal["Color"] = "cornflowerblue"
elif type(agent) is Corn:
portrayal["Color"] = "blueviolet"
elif type(agent) is Soy:
portrayal["Color"] = "forestgreen"
elif type(agent) is Bug:
portrayal["Shape"] = "circle"
portrayal["Color"] = "tomato"
portrayal["r"] = 1
portrayal["Layer"] = 1
return portrayal
bean = {"Label": "Bean", "Color": "cornflowerblue"}
corn = {"Label": "Corn", "Color": "blueviolet"}
soy = {"Label": "Soy", "Color": "forestgreen"}
bug = {"Label": "Bug", "Color": "tomato"}
canvas = CanvasGrid(food_portrayal, width, height)
chart_count = ChartModule([bean, corn, soy, bug])
model_params = {"strategy": "stick"}
server = ModularServer(Foraging, [canvas, chart_count], name="Foraging", model_params)
server.launch()
def __init__(self):
pass
def render(self, model):
return "Happy agents: " + str(model.happy)
def schelling_draw(agent):
'''
Portrayal Method for canvas
'''
if agent is None:
return
portrayal = {"Shape": "circle", "r": 0.5, "Filled": "true", "Layer": 0}
if agent.type == 0:
portrayal["Color"] = "Red"
else:
portrayal["Color"] = "Blue"
return portrayal
happy_element = HappyElement()
canvas_element = CanvasGrid(schelling_draw, 20, 20, 500, 500)
happy_chart = ChartModule([{"Label": "unhappy", "Color": "Black"}])
server = ModularServer(SchellingModel,
[canvas_element, happy_element, happy_chart],
"Schelling", 20, 20, 0.8, 0.2, 4)
server.verbose = False
server.port = 8889
server.launch()
