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): # 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): 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(): (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(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 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(): (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(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) 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.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): 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): # 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) # 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(): (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(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): (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 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): 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): (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(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): 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): 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(): (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): (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)
#!/usr/bin/env python3 """ A script to test our spatial capabilities. """ 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!"))
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(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)
#!/usr/bin/env python3 """ A script to test our two pop markov capabilities. """ import indra.utils as utils import indra.prop_args as props import indra.two_pop_markov as itpm import two_pop_markov_model as tpm # set up some file names: MODEL_NM = "two_pop_markov_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) 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",