The simulation in start.py

The best way to start creating a simulation is by copying the start.py file and other files from ‘abcEconomics/template’ in https://github.com/AB-CE/examples.

To see how to create a simulation, read ipython_tutorial.

This is a minimal template for a start.py:

from agent import Agent
from abcEconomics import *


simulation = Simulation(name='abcEconomics')
agents = simulation.build_agents(Agent, 'agent', 2)
for time in range(100):
    simulation.advance_round(time)
    agents.one()
    agents.two()
    agents.three()
simulation.finalize()

Note two things are important: there must be a

finalize() at the end otherwise the simulation blocks at the end. Furthermore, every round needs to be announced using simulation.advance_round(time), where time is any representation of time.

class abcEconomics.Simulation(name='abcEconomics', random_seed=None, trade_logging='off', processes=1, dbplugin=None, dbpluginargs=[], path='auto', multiprocessing_database=False)

Bases: object

This is the class in which the simulation is run. Actions and agents have to be added. Databases and resource declarations can be added. Then run the simulation.

Args:

name:

name of the simulation

random_seed (optional):

a random seed that controls the random number of the simulation

trade_logging:

Whether trades are logged,trade_logging can be ‘group’ (fast) or ‘individual’ (slow) or ‘off’

processes (optional):

The number of processes that runs in parallel. Each process hosts a share of the agents. By default, if this parameter is not specified, processes is all your logical processor cores times two, using hyper-threading when available. For easy debugging, set processes to one and the simulation is executed without parallelization. Sometimes it is advisable to decrease the number of processes to the number of logical or even physical processor cores on your computer. For easy debugging set processes to 1, this way only one agent runs at a time and only one error message is displayed

check_unchecked_msgs:

check every round that all messages have been received with get_massages or get_offers.

path:

path for database use None to omit directory creation.

dbplugin, dbpluginargs:

database plugin, see Database Plugins

Example:

simulation = Simulation(name='abcEconomics',
                        trade_logging='individual',
                        processes=None)

Example for a simulation:

num_firms = 5
num_households = 2000

w = Simulation(name='abcEconomics',
               trade_logging='individual',
               processes=None)

w.panel('firm', command='after_sales_before_consumption')

firms = w.build_agents(Firm, 'firm', num_firms)
households = w.build_agents(Household, 'household', num_households)

all = firms + households

for time in range(100):
    self.time = time
    endowment.refresh_services('labor', derived_from='labor_endowment', units=5)
    households.recieve_connections()
    households.offer_capital()
    firms.buy_capital()
    firms.production()
    if time == 250:
        centralbank.intervention()
    households.buy_product()
    all.after_sales_before_consumption()
    households.consume()

w.finalize()

advance_round(time)

build_agents(AgentClass, group_name, number=None, agent_parameters=None, **parameters)

This method creates agents.

Args:

AgentClass:

is the name of the AgentClass that you imported

group_name:

the name of the group, as it will be used in the action list and transactions. Should generally be lowercase of the AgentClass.

number:

number of agents to be created.

agent_parameters:

a list of dictionaries, where each agent gets one dictionary. The number of agents is the length of the list

any other parameters:

are directly passed to the agent

Example:

firms = simulation.build_agents(Firm, 'firm',
    number=simulation_parameters['num_firms'])
banks = simulation.build_agents(Bank, 'bank',
                                agent_parameters=[{'name': 'UBS'},
                                {'name': 'amex'},{'name': 'chase'}
                                **simulation_parameters,
                                loanable=True)

centralbanks = simulation.build_agents(CentralBank, 'centralbank',
                                       number=1,
                                       rounds=num_rounds)

create_agent(AgentClass, group_name, simulation_parameters=None, agent_parameters=None)

create_agents(AgentClass, group_name, simulation_parameters=None, agent_parameters=None, number=1)

delete_agent(*ang)

delete_agents(group, ids)

This deletes a group of agents. The model has to make sure that other agents are notified of the death of agents in order to stop them from corresponding with this agent. Note that if you create new agents after deleting agents the ID’s of the deleted agents are reused.

Args:

group:

group of the agent

ids:

a list of ids of the agents to be deleted in that group

finalize()

simulation.finalize() must be run after each simulation. It will write all data to disk

Example:

simulation = Simulation(...)
...
for r in range(100):
    simulation.advance_round(r)
    agents.do_something()
    ...

simulation.finalize()

time

Set and get time for simulation and all agents