def run():
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = ge.GridEnv("Obstacle env",
pa.get("grid_height"),
pa.get("grid_width"),
torus=False,
model_nm=MODEL_NM,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa.get("num_moving_agents")):
env.add_agent(om.ObstacleAgent(name="agent" + str(i),
goal="Avoiding obstacles!", max_move=4,
tolerance=2))
for i in range(pa.get("num_obstacles")):
env.add_agent(om.Obstacle(name="obstacle" + str(i)))
utils.run_model(env, prog_file, results_file)
def run():
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = ge.GridEnv("Obstacle env",
pa.get("grid_height"),
pa.get("grid_width"),
torus=False,
model_nm=MODEL_NM,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa.get("num_moving_agents")):
env.add_agent(
om.ObstacleAgent(name="agent" + str(i),
goal="Avoiding obstacles!",
max_move=4,
tolerance=2))
for i in range(pa.get("num_obstacles")):
env.add_agent(om.Obstacle(name="obstacle" + str(i)))
utils.run_model(env, prog_file, results_file)
def run():
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = itpm.TwoPopEnv("Test grid env",
pa.get("grid_width"),
pa.get("grid_height"),
torus=False,
model_nm=MODEL_NM,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
# Get Number of Followers
for i in range(pa.get("num_agents")):
env.add_agent(tpm.TestFollower(name="Follower" + str(i),
goal="taking up a grid space!",max_move=1))
# Get Number of Hipsters
for i in range(pa.get("num_agents")):
env.add_agent(tpm.TestLeader(name="Leader" + str(i),
goal="taking up a grid space!",max_move=1))
utils.run_model(env, prog_file, results_file)
def run(model_nm, prop_dict):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(model_nm)
pa = PropArgs(model_nm, prop_dict=prop_dict)
env = get_env(model_nm, pa)
utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.wolfsheep as wsm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# we create a meadow for our agents to act within:
env = wsm.Meadow("Meadow",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_wolves"]):
env.add_agent(wsm.Wolf("wolf" + str(i), "Eating sheep",
pa["wolf_repro"],
pa["wolf_lforce"],
rand_age=True))
for i in range(pa["num_sheep"]):
env.add_agent(wsm.Sheep("sheep" + str(i), "Reproducing",
pa["sheep_repro"],
pa["sheep_lforce"],
rand_age=True))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We need to create props before we import the model,
# as our choice of display_method is dependent on the user_type.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import models.politicalSine as ps
import indra.utils as utils
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = ps.BasicEnv(model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents
# with numbered names based on the loop variable:
AGENT_NUM = 0
for i in range(0, CITIZEN_NUM):
print(CITIZEN_POL_BELL[i])
env.add_agent(
ps.Citizen(name="CITagent" + str(AGENT_NUM),
goal="Voting" + str(CITIZEN_POL_BELL[i]),
political=CITIZEN_POL_BELL[i],
wealth=CITIZEN_WEALTH_BELL[i]))
AGENT_NUM += 1
for i in range(0, OLIGARCH_NUM):
env.add_agent(
ps.Citizen(name="OLIagent" + str(AGENT_NUM),
goal="Voting" + str(OLIGARCH_POL_BELL[i]),
political=OLIGARCH_POL_BELL[i],
wealth=OLIGARCH_WEALTH_BELL[i]))
AGENT_NUM += 1
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import bigbox.bigbox as bb
# set up some file names:
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We create a town for our agents to act in:
env = bb.EverytownUSA(pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_consumers"]):
env.add_agent(bb.Consumer("consumer" + str(i),
goal=(i % bb.NUM_GOODS),
init_state=0,
allowance=pa["allowance"]))
for i in range(pa["num_mom_and_pops"]):
env.add_agent(bb.MomAndPop("mom_and_pop" + str(i),
goal=(i % bb.NUM_GOODS),
endowment=pa["endowment"],
expenses=pa["expenses"],
adj=pa["pref_for_mp"]
))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
global pa
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ["base_dir"]
# Now we create a minimal environment for our agents to act within:
env = ge.GridEnv("Test grid env",
pa["grid_width"],
pa["grid_height"],
torus=False,
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_agents"]):
env.add_agent(
gm.TestGridAgent(name="agent" + str(i),
goal="taking up a grid space!"))
# let's test our iterator
for cell in env:
(x, y) = cell.coords
logging.info("Contents of cell x = " + str(x) + " and y = " + str(y) +
" is " + str(cell.contents))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.fmarket as fm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a asset environment for our agents to act within:
env = fm.FinMarket("Financial Market",
pa["grid_height"],
pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_followers"]):
env.add_agent(fm.ChartFollower("follower" + str(i),
"Following trend",
pa["fmax_move"],
pa["variability"]))
for i in range(pa["num_vinvestors"]):
env.add_agent(fm.ValueInvestor("value_inv" + str(i), "Buying value",
pa["vmax_move"],
pa["variability"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.fashion as fm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = fm.Society("Society",
pa["grid_height"],
pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_followers"]):
env.add_agent(fm.Follower("follower" + str(i),
"Looking like hipsters",
pa["fmax_move"],
pa["variability"]))
for i in range(pa["num_hipsters"]):
env.add_agent(fm.Hipster("hipster" + str(i), "Looking trendy",
pa["hmax_move"],
pa["variability"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
global pa
if prop_dict is not None:
prop_dict[props.PERIODS] = 0
pa.add_props(prop_dict)
else:
result = utils.read_props(MODEL_NM)
if result:
pa.add_props(result.props)
else:
utils.ask_for_params(pa)
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create a minimal environment for our agents to act within:
env = wm.WolframEnv("Wolfram Env",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa,
rule_id=pa["rule_id"])
# This env adds agents itself.
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.fashion as fm
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = fm.Society("Society",
pa["grid_height"],
pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_followers"]):
env.add_agent(
fm.Follower("follower" + str(i), "Looking like hipsters",
pa["fmax_move"], pa["variability"]))
for i in range(pa["num_hipsters"]):
env.add_agent(
fm.Hipster("hipster" + str(i), "Looking trendy", pa["hmax_move"],
pa["variability"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# now we run some tests:
# test prop_args as an iterable:
for prop, val in pa.items():
print(prop + ": " + str(val))
# test that props work as a dictionary:
if "num_agents" in pa:
print("In is working!")
# test what pa["num_agents"] is:
num_agents = pa["num_agents"]
print("num_agents = " + str(num_agents))
# make sure we can get props length:
print("Props length = " + str(len(pa)))
# Now we create a minimal environment for our agents to act within:
env = bm.BasicEnv(model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents
# with numbered names based on the loop variable:
for i in range(num_agents):
env.add_agent(bm.BasicAgent(name="agent" + str(i), goal="acting up!"))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.forestfire as fm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ["base_dir"]
grid_x = pa["grid_width"]
grid_y = pa["grid_height"]
density = pa["density"]
# Now we create a forest environment for our agents to act within:
env = fm.ForestEnv(grid_x,
grid_y,
density,
pa["strike_freq"],
pa["regen_period"],
model_nm=MODEL_NM,
torus=False,
props=pa)
num_agents = int(grid_x * grid_y * density)
for i in range(num_agents):
env.add_agent(fm.Tree(name="tree" + str(i)))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.fmarket as fm
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a asset environment for our agents to act within:
env = fm.FinMarket("Financial Market",
pa["grid_height"],
pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_followers"]):
env.add_agent(
fm.ChartFollower("follower" + str(i), "Following trend",
pa["fmax_move"], pa["variability"]))
for i in range(pa["num_vinvestors"]):
env.add_agent(
fm.ValueInvestor("value_inv" + str(i), "Buying value",
pa["vmax_move"], pa["variability"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
global pa
# we create an Infected Zone for our agents to act within:
env = zom.Zone("Infected Zone",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_zombies"]):
env.add_agent(zom.Zombie("Zombie" + str(i), "Eating Human",
pa["zombie_repro"],
pa["zombie_lforce"],
rand_age=True))
for i in range(pa["num_humans"]):
env.add_agent(zom.Human("Human" + str(i), "Reproducing",
pa["human_repro"],
pa["human_lforce"],
rand_age=True))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import indra.grid_env as ge
import models.grid as gm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ["base_dir"]
# Now we create a minimal environment for our agents to act within:
env = ge.GridEnv("Test grid env",
pa["grid_width"],
pa["grid_height"],
torus=False,
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_agents"]):
env.add_agent(gm.TestGridAgent(name="agent" + str(i),
goal="taking up a grid space!"))
# let's test our iterator
for cell in env:
(x, y) = cell.coords
logging.info("Contents of cell x = " + str(x)
+ " and y = " + str(y)
+ " is " + str(cell.contents))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
global pa
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ["base_dir"]
grid_x = pa["grid_width"]
grid_y = pa["grid_height"]
density = pa["density"]
# Now we create a forest environment for our agents to act within:
env = fm.ForestEnv(grid_x,
grid_y,
density,
pa["strike_freq"],
pa["regen_period"],
model_nm=MODEL_NM,
torus=False,
props=pa)
num_agents = int(grid_x * grid_y * density)
for i in range(num_agents):
env.add_agent(fm.Tree(name="tree" + str(i)))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import bigbox.bigbox as bb
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We create a town for our agents to act in:
env = bb.EverytownUSA(pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_consumers"]):
env.add_agent(
bb.Consumer("consumer" + str(i),
goal=(i % bb.NUM_GOODS),
init_state=0,
allowance=pa["allowance"]))
for i in range(pa["num_mom_and_pops"]):
env.add_agent(
bb.MomAndPop("mom_and_pop" + str(i),
goal=(i % bb.NUM_GOODS),
endowment=pa["endowment"],
expenses=pa["expenses"],
adj=pa["pref_for_mp"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.wolfsheep as wsm
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# we create a meadow for our agents to act within:
env = wsm.Meadow("Meadow",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_wolves"]):
env.add_agent(
wsm.Wolf("wolf" + str(i),
"Eating sheep",
pa["wolf_repro"],
pa["wolf_lforce"],
rand_age=True))
for i in range(pa["num_sheep"]):
env.add_agent(
wsm.Sheep("sheep" + str(i),
"Reproducing",
pa["sheep_repro"],
pa["sheep_lforce"],
rand_age=True))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
global pa
env = cm.CoopEnv(model_nm=MODEL_NM, props=pa)
for i in range(pa["num_agents"]):
env.add_agent(cm.CoopAgent('agent' + str(i), 5, 0))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file,
prop_file, results_file) = utils.gen_file_names(MODEL_NM)
global pa
env = cm.CoopEnv(model_nm=MODEL_NM, props=pa)
for i in range(pa["num_agents"]):
env.add_agent(
cm.CoopAgent('agent' + str(i), 5, 0))
return utils.run_model(env, prog_file, results_file)
def run():
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = itpm.TwoPopEnv("Test grid env",
pa.get("grid_width"),
pa.get("grid_height"),
torus=False,
model_nm=MODEL_NM,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
# Get Number of Followers
for i in range(pa.get("num_agents")):
env.add_agent(
tpm.TestFollower(name="Follower" + str(i),
goal="taking up a grid space!",
max_move=1))
# Get Number of Hipsters
for i in range(pa.get("num_agents")):
env.add_agent(
tpm.TestLeader(name="Leader" + str(i),
goal="taking up a grid space!",
max_move=1))
utils.run_model(env, prog_file, results_file)
def run():
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store menu parameters in a
# "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = mm.MenuEnv(model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents
# with numbered names based on the loop variable:
for i in range(pa.get("num_agents")):
env.add_agent(
mm.MenuAgent(name="agent" + str(i),
goal="testing our menu capabilities!"))
utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import schelling.height as hm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
env = hm.HeightEnv(model_nm=MODEL_NM, props=pa)
for i in range(pa["num_agents"]):
env.add_agent(
hm.HeightAgentEng('Eng agent' + str(i),
START_HEIGHT, START_HEIGHT))
env.add_agent(
hm.HeightAgent('agent' + str(i), START_HEIGHT, START_HEIGHT))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
global pa
env = hm.HeightEnv(model_nm=MODEL_NM, props=pa)
for i in range(pa["num_agents"]):
env.add_agent(
hm.HeightAgentEng('Eng agent' + str(i), START_HEIGHT,
START_HEIGHT))
env.add_agent(
hm.HeightAgent('agent' + str(i), START_HEIGHT, START_HEIGHT))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
global pa
# Now we create an environment for our agents to act within:
env = am.Auditorium("Auditorium",
height=pa["grid_height"],
width=pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
num_agents=pa["num_agents"],
props=pa)
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import schelling.height as hm
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
env = hm.HeightEnv(model_nm=MODEL_NM, props=pa)
for i in range(pa["num_agents"]):
env.add_agent(
hm.HeightAgentEng('Eng agent' + str(i), START_HEIGHT,
START_HEIGHT))
env.add_agent(
hm.HeightAgent('agent' + str(i), START_HEIGHT, START_HEIGHT))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file,
prop_file, results_file) = utils.gen_file_names(MODEL_NM)
global pa
# Now we create an environment for our agents to act within:
env = am.Auditorium("Auditorium",
height=pa["grid_height"],
width=pa["grid_width"],
torus=False,
model_nm=MODEL_NM,
num_agents=pa["num_agents"],
props=pa)
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.sand as sm
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = sm.SandEnv("Abelian sand env",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa)
# This env adds agents itself.
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.sim_interactive as sm
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create an environment for our agents to act within:
env = sm.SimInteractiveEnv("Car_sim",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa)
# create given number of slow vehicles
# print(sm)
max_speed = pa["max_speed"]
min_speed = pa["min_speed"]
# East bound cars
for i in range(pa["slow_car_num"]):
newAgent = sm.EastCar('Vehicle #' + str(i),
random.randint(min_speed, max_speed))
env.add_agent(newAgent)
env.move(newAgent, i + 2, env.height // 2)
# South bound cars
num_north_cars = pa["slow_car_num"]
for i in range(pa["fast_car_num"]):
newAgent = sm.SouthCar('Vehicle #' + str(i + num_north_cars),
random.randint(min_speed, max_speed))
env.add_agent(newAgent)
env.move(newAgent, env.width // 2, env.height - (i + 2))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.standing_ovation as wsm
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
env = wsm.Auditorium("Auditorium",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
props=pa)
num_agents = int(pa["grid_width"] * pa["grid_height"])
for i in range(num_agents):
env.add_agent(wsm.Member("member" + str(i), "Enjoying the show", pa["noise_level"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import schelling.segregation as sm
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create an environment for our agents to act within:
env = sm.SegregationEnv("A city",
pa["grid_width"],
pa["grid_height"],
model_nm=pa.model_nm,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_B_agents"]):
env.add_agent(
sm.BlueAgent(name="Blue agent" + str(i),
goal="A good neighborhood.",
min_tol=pa['min_tolerance'],
max_tol=pa['max_tolerance'],
max_detect=pa['max_detect']))
for i in range(pa["num_R_agents"]):
env.add_agent(
sm.RedAgent(name="Red agent" + str(i),
goal="A good neighborhood.",
min_tol=pa['min_tolerance'],
max_tol=pa['max_tolerance'],
max_detect=pa['max_detect']))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.party as pm
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create an environment for our agents to act within:
env = pm.PartyEnv("A cocktail party",
pa["grid_width"],
pa["grid_height"],
model_nm=pa.model_nm,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_men"]):
env.add_agent(
pm.Man(name="Man" + str(i),
goal="A good party.",
tol=0.5,
max_detect=pa['max_detect']))
for i in range(pa["num_women"]):
env.add_agent(
pm.Woman(name="Woman" + str(i),
goal="A good party.",
tol=0.5,
max_detect=pa['max_detect']))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import schelling.segregation as sm
# set up some file names:
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create an environment for our agents to act within:
env = sm.SegregationEnv("A city",
pa["grid_width"],
pa["grid_height"],
model_nm=pa.model_nm,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_B_agents"]):
env.add_agent(sm.BlueAgent(name="Blue agent" + str(i),
goal="A good neighborhood.",
min_tol=pa['min_tolerance'],
max_tol=pa['max_tolerance'],
max_detect=pa['max_detect']))
for i in range(pa["num_R_agents"]):
env.add_agent(sm.RedAgent(name="Red agent" + str(i),
goal="A good neighborhood.",
min_tol=pa['min_tolerance'],
max_tol=pa['max_tolerance'],
max_detect=pa['max_detect']))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.standing_ovation as wsm
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
env = wsm.Auditorium("Auditorium",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
props=pa)
num_agents = int(pa["grid_width"] * pa["grid_height"])
for i in range(num_agents):
env.add_agent(
wsm.Member("member" + str(i), "Enjoying the show",
pa["noise_level"]))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import wolfram.wolfram as wm
import indra.utils as utils
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = wm.WolframEnv("Wolfram Env",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa,
rule_id=pa["rule_id"])
# This env adds agents itself.
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import wolfram.wolfram as wm
import indra.utils as utils
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = wm.WolframEnv("Wolfram Env",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
props=pa,
rule_id=pa["rule_id"])
# This env adds agents itself.
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.party as pm
# set up some file names:
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
if pa["user_type"] == props.WEB:
pa["base_dir"] = os.environ['base_dir']
# Now we create an environment for our agents to act within:
env = pm.PartyEnv("A cocktail party",
pa["grid_width"],
pa["grid_height"],
model_nm=pa.model_nm,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa["num_men"]):
env.add_agent(pm.Man(name="Man" + str(i),
goal="A good party.",
tol=0.5,
max_detect=pa['max_detect']))
for i in range(pa["num_women"]):
env.add_agent(pm.Woman(name="Woman" + str(i),
goal="A good party.",
tol=0.5,
max_detect=pa['max_detect']))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
global pa ## <--- My guy, do you have a license for this??
# we create a meadow for our agents to act within:
env = zom.Zone("Infected Zone",
pa["grid_width"],
pa["grid_height"],
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
# Now we loop creating multiple agents with numbered names
# based on the number of agents of that type to create:
for i in range(pa["num_zombies"]):
env.add_agent(
zom.Zombie("Zombie" + str(i),
"Eating Human",
pa["zombie_repro"],
pa["zombie_lforce"],
rand_age=True))
for i in range(pa["num_humans"]):
#### We need to add human attributes to make this part work.
#### We need to add module functions in a more working manner
env.add_agent(
zom.Human(
"Human" + str(i),
"Reproducing",
## Delete the following comments when human attributes are fixed
4, #pa["human_repro"],
4, #pa["human_lforce"],
rand_age=True))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We need to create props before we import the basic model,
# as our choice of display_method is dependent on the user_type.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import models.basic as bm
import indra.utils as utils
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
# test prop_args as an iterable:
for prop, val in pa.items():
print(prop + ": " + str(val))
# test that props work as a dictionary:
if "num_agents" in pa:
print("In is working!")
# test what pa["num_agents"] is:
num_agents = pa["num_agents"]
print("num_agents = " + str(num_agents))
# make sure we can get props length:
print("Props length = " + str(len(pa)))
# Now we create a minimal environment for our agents to act within:
env = bm.BasicEnv(model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents
# with numbered names based on the loop variable:
for i in range(num_agents):
env.add_agent(bm.BasicAgent(name="agent" + str(i),
goal="acting up!"))
return utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
# We need to create props before we import the model,
# as our choice of display_method is dependent on the user_type.
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import models.politicalSine as ps
import indra.utils as utils
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# Now we create a minimal environment for our agents to act within:
env = ps.BasicEnv(model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents
# with numbered names based on the loop variable:
AGENT_NUM = 0
for i in range(0, CITIZEN_NUM):
print(CITIZEN_POL_BELL[i])
env.add_agent(ps.Citizen(name="CITagent"
+ str(AGENT_NUM), goal="Voting" + str(CITIZEN_POL_BELL[i]),
political=CITIZEN_POL_BELL[i],
wealth=CITIZEN_WEALTH_BELL[i]
)
)
AGENT_NUM += 1
for i in range(0, OLIGARCH_NUM):
env.add_agent(ps.Citizen(name="OLIagent"
+ str(AGENT_NUM), goal="Voting" + str(OLIGARCH_POL_BELL[i]),
political=OLIGARCH_POL_BELL[i],
wealth=OLIGARCH_WEALTH_BELL[i]
)
)
AGENT_NUM += 1
return utils.run_model(env, prog_file, results_file)
"""
import indra.utils as utils
import indra.prop_args as props
import indra.spatial_env as se
import models.spatial as sm
# set up some file names:
MODEL_NM = "spatial_model"
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(MODEL_NM)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
# Now we create a minimal environment for our agents to act within:
env = se.SpatialEnv("Test spatial env", 100.0, 100.0,
model_nm=MODEL_NM, props=pa)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
for i in range(pa.get("num_agents")):
env.add_agent(
sm.TestSpatialAgent(name="agent" + str(i),
goal="moving around aimlessly!"))
utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.hiv as hiv
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
grid_x = pa["grid_width"]
grid_y = pa["grid_height"]
ini_ppl = pa["ini_ppl"]
avg_coup_tend = pa["avg_coup_tend"]
avg_test_freq = pa["avg_test_freq"]
avg_commitment = pa["avg_commitment"]
avg_condom_use = pa["avg_condom_use"]
max_ppl = grid_x * grid_y
if ini_ppl > max_ppl:
ini_ppl = max_ppl
# Now we create an environment for our agents to act within:
env = hiv.People("People",
grid_x,
grid_y,
model_nm=MODEL_NM,
preact=True,
postact=True,
props=pa)
ini_infected_ppl = round(INI_INFECTED_PCT * ini_ppl)
ini_healthy_ppl = ini_ppl - ini_infected_ppl
# print("initial infected people:", ini_infected_ppl)
# print("initial healthy people:", ini_healthy_ppl)
coup_tend = numpy.random.normal(avg_coup_tend, STD_COUP_TEND, ini_ppl)
test_freq = numpy.random.normal(avg_test_freq, STD_TEST_FREQ, ini_ppl)
commitment = numpy.random.normal(avg_commitment, STD_COMMITMENT, ini_ppl)
condom_use = numpy.random.normal(avg_condom_use, STD_CONDOM_USE, ini_ppl)
for i in range(ini_ppl):
if coup_tend[i] < 0:
coup_tend[i] = 0
elif coup_tend[i] > 10:
coup_tend[i] = 10
if test_freq[i] < 0:
test_freq[i] = 0
elif test_freq[i] > 2:
test_freq[i] = 2
if commitment[i] < 1:
commitment[i] = 1
elif commitment[i] > 200:
commitment[i] = 200
if condom_use[i] < 0:
condom_use[i] = 0
elif condom_use[i] > 10:
condom_use[i] = 10
for i in range(ini_infected_ppl):
rand_inf_len = random.randint(0, hiv.SYMPTOMS_SHOW - 1)
new_agent = hiv.Person(name="person" + str(i),
infected=True,
infection_length=rand_inf_len,
initiative=i,
coupling_tendency=coup_tend[i],
test_frequency=test_freq[i],
commitment=commitment[i],
condom_use=condom_use[i])
env.add_agent(new_agent)
for i in range(ini_healthy_ppl):
new_agent = hiv.Person(name="person" + str(ini_infected_ppl + i),
infected=False,
infection_length=0,
initiative=ini_infected_ppl + i,
coupling_tendency=coup_tend[ini_infected_ppl +
i],
test_frequency=test_freq[ini_infected_ppl + i],
commitment=commitment[ini_infected_ppl + i],
condom_use=condom_use[ini_infected_ppl + i])
env.add_agent(new_agent)
return utils.run_model(env, prog_file, results_file)
def run(model_nm, prop_dict):
(prog_file, log_file, prop_file, results_file) = utils.gen_file_names(model_nm)
pa = PropArgs(model_nm, prop_dict=prop_dict)
env = get_env(model_nm, pa)
utils.run_model(env, prog_file, results_file)
def run(prop_dict=None):
pa = props.PropArgs.create_props(MODEL_NM, prop_dict)
import indra.utils as utils
import models.hiv as hiv
(prog_file, log_file, prop_file,
results_file) = utils.gen_file_names(MODEL_NM)
grid_x = pa["grid_width"]
grid_y = pa["grid_height"]
ini_ppl = pa["ini_ppl"]
avg_coup_tend = pa["avg_coup_tend"]
avg_test_freq = pa["avg_test_freq"]
avg_commitment = pa["avg_commitment"]
avg_condom_use = pa["avg_condom_use"]
max_ppl = grid_x * grid_y
if ini_ppl > max_ppl:
ini_ppl = max_ppl
# Now we create an environment for our agents to act within:
env = hiv.People("People", grid_x, grid_y, model_nm=MODEL_NM,
preact=True, postact=True, props=pa)
ini_infected_ppl = round(INI_INFECTED_PCT * ini_ppl)
ini_healthy_ppl = ini_ppl - ini_infected_ppl
# print("initial infected people:", ini_infected_ppl)
# print("initial healthy people:", ini_healthy_ppl)
coup_tend = numpy.random.normal(avg_coup_tend, STD_COUP_TEND, ini_ppl)
test_freq = numpy.random.normal(avg_test_freq, STD_TEST_FREQ, ini_ppl)
commitment = numpy.random.normal(avg_commitment, STD_COMMITMENT, ini_ppl)
condom_use = numpy.random.normal(avg_condom_use, STD_CONDOM_USE, ini_ppl)
for i in range(ini_ppl):
if coup_tend[i] < 0:
coup_tend[i] = 0
elif coup_tend[i] > 10:
coup_tend[i] = 10
if test_freq[i] < 0:
test_freq[i] = 0
elif test_freq[i] > 2:
test_freq[i] = 2
if commitment[i] < 1:
commitment[i] = 1
elif commitment[i] > 200:
commitment[i] = 200
if condom_use[i] < 0:
condom_use[i] = 0
elif condom_use[i] > 10:
condom_use[i] = 10
for i in range(ini_infected_ppl):
rand_inf_len = random.randint(0, hiv.SYMPTOMS_SHOW-1)
new_agent = hiv.Person(name="person" + str(i),
infected=True,
infection_length=rand_inf_len,
initiative=i,
coupling_tendency=coup_tend[i],
test_frequency=test_freq[i],
commitment=commitment[i],
condom_use=condom_use[i])
env.add_agent(new_agent)
for i in range(ini_healthy_ppl):
new_agent = hiv.Person(name="person" + str(ini_infected_ppl+i),
infected=False, infection_length=0,
initiative=ini_infected_ppl+i,
coupling_tendency=coup_tend[ini_infected_ppl+i],
test_frequency=test_freq[ini_infected_ppl+i],
commitment=commitment[ini_infected_ppl+i],
condom_use=condom_use[ini_infected_ppl+i])
env.add_agent(new_agent)
return utils.run_model(env, prog_file, results_file)
# We store basic parameters in a "property" file; this allows us to save
# multiple parameter sets, which is important in simulation work.
# We can read these in from file or set them here.
pa = utils.read_props(MODEL_NM)
if pa is None:
pa = props.PropArgs(MODEL_NM, logfile=log_file, props=None)
utils.get_grid_dims(pa, 6)
utils.get_agent_num(pa, "num_agents", "agents", 16)
# Now we create a minimal environment for our agents to act within:
env = itpm.TwoPopEnv(
"Test two pop Markov env",
pa.get("grid_width"),
pa.get("grid_height"),
preact=True,
postact=True,
trans_str="0.5 0.5; 0.5 0.5",
model_nm=MODEL_NM,
torus=False,
)
# Now we loop creating multiple agents with numbered names
# based on the loop variable:
# Get Number of Followers
for i in range(pa.get("num_agents")):
env.add_agent(
tpm.TestFollower(name="Follower" + str(i), goal="Changing states!"))
utils.run_model(env, prog_file, results_file)
