Agent( str breed, int id, Helipad model )

The Agent class contains the logic for agent behavior. The bulk of a model’s code will be hooked into agentStep.

Agent is the class used for the default 'agent' primitive. Other primitives can be created by subclassing baseAgent.

Initialization Parameters

• breed — str, required

  The breed of the newly created agent.

• id — int, required

  A globally unique ID for the agent. Unexpected results may occur if non-unique ids are used.

• model — Helipad, required

  The model object.

Methods

Click a method name for more detailed documentation.

• buy( partner, good, q, … )

  Purchases a good from another agent and pays for it using the monetary good specified in a Goods.add() command. Similar to agent.trade() except that the second good does not have to be specified. Note that this function will raise a RuntimeError if no monetary good has been specified.

• die( )

  Removes the agent from the model's list of active agents and cuts the agent's edges.

  This function also decrements the pseudo-parameter for the agent's primitive population. For this reason it has one optional argument for internal use that should not be used in user code.

  This function can be hooked with agentDie.

• edgesWith( partner, kind )

  Returns a list of direct connections with another agent. Does not indicate indirect connections.

• inbound( kind, undirected, obj )

  Returns a list of edges for which the agent is an endpoint.

• newEdge( partner, kind, direction, … )

  Creates a new Edge object between the current agent and a new agent, for use in graphs and networks.

• outbound( kind, undirected, obj )

  Returns a list of edges for which the agent is a startpoint.

• pay( recipient, amount )

  Unilaterally transfers an amount of the monetary good from the agent to a recipient, or from the recipient to the agent if amount<0. Note that this function will raise a RuntimeError if no monetary good has been specified.

• reproduce( inherit, mutate, partners )

  Spawns a new agent, inheriting specified properties from the parent agent. The parent agent is stored in the child's agent.parent, and the child agent is added to the parent agent's agent.children list. Properties not specified in either the inherit or mutate arguments will be instantiated according to the agent.__init__() function (and therefore after the agentInit hook runs on the child agent).

  NOTE. This function accounts for parents and children by creating a directed network titled 'lineage'.

• trade( partner, good1, amt1, … )

  Exchanges a quantity of one good for a quantity of another good, and records the demand for each. Requires at least two goods to have been registered, but does not require a monetary good. Ordinary usage would be giving up amt1 of good1 to get amt2 of good2, but negative amounts can reverse the direction.

• transfer( dest )

  In a multi-level model, this function allows an agent of a sub-model to move to a different sub-model. Agents can also move to and from the top-level model, for example if agents can join firms or exit them to compete as independent contractors.

  This function can be hooked with agentTransfer.

• step( stage )

  A function that runs for each agent in each period and increments the agent's age by 1. This function should not be called directly, but should be hooked using agentStep or baseAgentStep.

Properties

• id — int

  A globally unique agent ID, assigned when the agent is instantiated.

• age — int

  The number of periods since the agent was initialized. Note that age stops incrementing once the agent dies.

  Initial value: 0

• dead — bool

  Whether the agent remains in the queue to be activated each period. See agent.die().

  Initial value: False

• stocks — dict{str:num}

  Keeps track of agents' stocks of goods. Keys correspond to goods registered with Goods.add().

  Initial value: {}

• currentDemand — dict{str:num}

  Keeps track of how much of each good the agent obtained. Note that selling a good does not register as negative demand, otherwise net demand would always be zero. See agent.trade() and agent.buy().

  Initial value: {}

• balance — int

  If a monetary good is registered, this property returns the agent's stock of the monetary good. Equivalent to agent.stocks[model.goods.money].

  Initial value: None

• parent — Agent|list[Agent]

  The agent (if haploid) or a list of agents (if polyploid) from which the current agent was spawned. See agent.reproduce(). Agents created at the initialization of the model have no parent.

  Initial value: None

• children — list[Agent]

  A list of agents spawned from the current agent. See agent.reproduce().

  Initial value: []

• edges — dict{str: list[Edge]}

  Stores the agent's active edges, for use in network and graph models. Keys correspond to the kinds of edges, and values are lists of edges of that type.

  Initial value: {}

• alledges — list[Edge]

  A flat list containing all edges of all kinds connected to the agent.

  Initial value: []

• primitive — str

  The name of the primitive the agent belongs to. Note: the primitive property attaches to the agent class and not the object. It can be accessed like an object property, but should not be modified.

• fixed — bool

  If True, the agent population is fixed and cannot reproduce or die. Patches in a spatial model are a fixed primitive, for example. It should be set as a static property of the class passed to Primitives.add() and cannot be set on a per-agent basis.

  Initial value: False

• overdraft — str

  Controls agent behavior when agent.trade() or agent.pay() have the agent giving up more stocks of a good than he possesses. Available options are:

  1. 'allow': Allow agents to run negative balances of goods.
  2. 'continue-silent': Continues the trade with the available stock, leaving the payer with 0.
  3. 'continue-warn': Continues the trade with the available stock and emits a warning.
  4. 'fail-silent': Cancels the trade.
  5. 'fail-warn': Cancels the trade and emits a warning.
  6. 'stop': Raises a ValueError.
  Note that this is a static property attached to the class and not to the object, so setting it once sets it globally for the primitive. Setting baseAgent.overdraft will set it for all primitives unless a primitive has specifically overridden the value.

  Initial value: 'continue-silent'

Hooks

Click a hook name for more detailed documentation.

• agentTransfer( agent, origin, dest )

  Runs when an agent transfers from one model to another in a multi-level model. This hook generalizes to [primitive]Transfer, e.g. an agent of primitive 'worker' could be hooked with workerTransfer. To hook the moving of agents of all primitives, use baseAgentTransfer.

• checkBalance( agent, balance, model )

  Modifies the value returned by agent.balance. Allows agents' money balances to be filtered, e.g. if they hold money in a form other than the registered money good that ought to be counted toward total balances.

• agentDie( agent )

  Runs when an agent dies. This hook generalizes to [primitive]Die, e.g. the death of an agent with primitive 'bank' could be hooked with bankDie. To hook the death of agents of all primitives, use baseAgentDie.

• agentReproduce( parents, child, model )

  Runs when an agent reproduces. This hook generalizes to [primitive]Reproduce, e.g. the death of an agent with primitive 'bank' would be hooked with bankReproduce. To hook the reproduction of agents of all primitives, use baseAgentReproduce.

• pay( agent, recipient, amount, … )

  Runs when an agent pays another agent. This hook can allow payment to be diverted into forms other than a transfer of the monetary good.

• buy( agent, partner, good, … )

  Runs when an agent purchases a good with money and allows the quantity passed to the function to be modified.

• postTrade( agent, partner, good1, … )

  Runs after an agent completes a trade of one good for another. Note that because agent.buy() aliases agent.trade(), this hook will also run when agents buy using the monetary good as well.

• preTrade( agent, partner, good1, … )

  Runs before an agent completes a trade of one good for another. Note that because agent.buy() aliases agent.trade(), this hook will also run when agents buy using the monetary good as well.

• agentStep( agent, model, stage )

  Runs when the model activates an agent. The main logic of an agent-based model should be hooked here.

  This hook generalizes to [primitive]Step, e.g. the step function of an agent with primitive 'bank' would be hooked with bankStep. To hook the step function of agents of all primitives, use baseAgentStep.

  The list of agents to be stepped is finalized at the beginning of each stage, so any agent who is alive at the beginning of the stage will be stepped, even in the unusual case that it dies between then and its actual stepping. If this is undesired, if agent.dead: return at the beginning of the hook will prevent this.

• agentInit( agent, model )

  Runs during the initialization of an agent. This hook generalizes to [primitive]Init, e.g. the initialization of an agent with primitive 'bank' would be hooked with bankInit. To hook the death of agents of all primitives, use baseAgentInit.