vivarium.core.experiment module

Experiment and Store Classes

class vivarium.core.experiment.Defer(defer, f, args)

Bases: object

get()

class vivarium.core.experiment.Electron(parameters=None)

Bases: vivarium.core.process.Process

defaults = {'spin': '-1/2', 'time_step': 1.0}

name = 'electron'

next_update(timestep, states)

ports_schema()

class vivarium.core.experiment.Experiment(config)

Bases: object

Defines simulations

Parameters

config (dict) –

A dictionary of configuration options. The required options are:

• processes (dict): A dictionary that

  maps process names to process objects. You will usually get this from the processes attribute of the dictionary from vivarium.core.experiment.Compartment.generate().

• topology (dict): A dictionary that

  maps process names to sub-dictionaries. These sub-dictionaries map the process’s port names to tuples that specify a path through the tree from the compartment root to the store that will be passed to the process for that port.

The following options are optional:

• experiment_id (uuid.UUID or

  str): A unique identifier for the experiment. A UUID will be generated if none is provided.

• description (str): A description of

  the experiment. A blank string by default.

• initial_state (dict): By default an

  empty dictionary, this is the initial state of the simulation.

• emitter (dict): An emitter

  configuration which must conform to the specification in the documentation for vivarium.core.emitter.get_emitter(). The experiment ID will be added to the dictionary you provide as the value for the key experiment_id.

apply_update(update, process_topology, state)

emit_configuration()

emit_data()

end()

invoke_process(process, path, interval, states)

process_update(path, state, interval)

run_derivers(derivers)

send_updates(update_tuples, derivers=None)

update(interval)

Run each process for the given interval and update the related states.

class vivarium.core.experiment.InvokeProcess(process, interval, states)

Bases: object

get(timeout=0)

class vivarium.core.experiment.MultiInvoke(pool)

Bases: object

invoke(process, interval, states)

class vivarium.core.experiment.Proton(parameters=None)

Bases: vivarium.core.process.Process

defaults = {'radius': 0.0, 'time_step': 1.0}

name = 'proton'

next_update(timestep, states)

ports_schema()

class vivarium.core.experiment.Sine(parameters=None)

Bases: vivarium.core.process.Process

defaults = {'initial_phase': 0.0}

name = 'sine'

next_update(timestep, states)

ports_schema()

class vivarium.core.experiment.Store(config, outer=None, source=None)

Bases: object

Holds a subset of the overall model state

The total state of the model can be broken down into stores, each of which is represented by an instance of this Store class. The store’s state is a set of variables, each of which is defined by a set of schema key-value pairs. The valid schema keys are listed in schema_keys, and they are:

• _default (Type should match the variable value): The default value of the variable.

• _updater (str): The name of the updater to use. By default this is accumulate.

• _divider (str): The name of the divider to use. Note that _divider is not included in the schema_keys set because it can be applied to any node in the hierarchy, not just leaves (which represent variables).

• _value (Type should match the variable value): The current value of the variable. This is None by default.

• _properties (dict): Extra properties of the variable that don’t have a specific schema key. This is an empty dictionary by default.

• _emit (bool): Whether to emit the variable to the emitter. This is False by default.

apply_config(config, source=None)

Expand the tree by applying additional config.

Special keys for the config are: * _default - Default value for this node. * _properties - An arbitrary map of keys to values. This can be used

for any properties which exist outside of the operation of the tree (like mass or energy).

• _updater - Which updater to use. Default is ‘accumulate’ which

  adds the new value to the existing value, but ‘set’ is common as well. You can also provide your own function here instead of a string key into the updater library.

• _emit - whether or not to emit the values under this point in the tree.

• _divider - What to do with this node when division happens.

  Default behavior is to leave it alone, but you can also pass ‘split’ here, or a function of your choosing. If you need other values from the state you need to supply a dictionary here containing the updater and the topology for where the other state values are coming from. This has two keys: * divider - a function that takes the existing value and any

  values supplied from the adjoining topology.

  • topology - a mapping of keys to paths where the value for

    those keys will be found. This will be passed in as the second argument to the divider function.

• _subschema/* - If this node was declared to house an unbounded set

  of related states, the schema for these states is held in this nodes subschema and applied whenever new subkeys are added here.

• _subtopology - The subschema is informed by the subtopology to

  map the process perspective to the actual tree structure.

apply_defaults()

If value is None, set to default.

apply_subschema(subschema=None, subtopology=None, source=None)

Apply a subschema to all inner nodes (either provided or from this node’s personal subschema) as governed by the given/personal subtopology.

apply_subschema_config(subschema)

apply_subschemas()

Apply all subschemas from all nodes at this point or lower in the tree.

apply_update(update, process_topology=None, state=None)

Given an arbitrary update, map all the values in that update to their positions in the tree where they apply, and update these values using each node’s _updater.

There are five special update keys:

• _updater - Override the default updater with any updater you want.

• _delete - The value here is a list of paths to delete from

  the tree.

• _add - Adds a state into the subtree:

  • path - Path to the added state key.

  • state - The value of the added state.

• _generate - The value has four keys, which are essentially

  the arguments to the generate() function: * path - Path into the tree to generate this subtree. * processes - Tree of processes to generate. * topology - Connections of all the process’s ports_schema(). * initial_state - Initial state for this new subtree.

• _divide - Performs cell division by constructing two new

  daugther cells and removing the mother. Takes a dict with two keys: * mother - The id of the mother (for removal) * daughters - List of two new daughter generate directives, of the

  same form as the _generate value above.

• _reduce - This allows a reduction over the entire subtree from some

  point downward. Its three keys are: * from - What point to start the reduction. * initial - The initial value of the reduction. * reducer - A function of three arguments, which is called

  on every node from the from point in the tree down: * value - The current accumulated value of the reduction. * path - The path to this point in the tree * node - The actual node being visited. This function returns the next value for the reduction. The result of the reduction will be assigned to this point in the tree.

check_default(new_default)

check_value(new_value)

delete_path(path)

Delete the subtree at the given path.

depth(path=())

Create a mapping of every path in the tree to the node living at that path in the tree.

divide_value()

Apply the divider for each node to the value in that node to assemble two parallel divided states of this subtree.

emit_data()

establish_path(path, config, source=None)

Create a node at the given path if it does not exist, then apply a config to it.

Paths can include ‘..’ to go up a level (which raises an exception if that level does not exist).

generate(path, processes, topology, initial_state)

Generate a subtree of this store at the given path. The processes will be mapped into locations in the tree by the topology, and once everything is constructed the initial_state will be applied.

generate_paths(processes, topology)

get_config(sources=False)

Assemble a dictionary representation of the config for this node. A desired property is that the node can be exactly recreated by applying the resulting config to an empty node again.

get_in(path)

get_path(path)

Get the node at the given path relative to this node.

get_paths(paths)

get_template(template)

Pass in a template dict with None for each value you want to retrieve from the tree!

get_updater(update)

get_value(condition=None, f=None)

Pull the values out of the tree in a structure symmetrical to the tree.

get_values(paths)

inner_value(key)

Get the value of an inner state

mark_deleted()

When nodes are removed from the tree, they are marked as deleted in case something else has a reference to them.

merge_subtopology(subtopology)

outer_path(path, source=None)

Address a topology with the _path keyword if present, establishing a path to this node and using it as the starting point for future path operations.

path_for()

Find the path to this node.

processes(path=())

reduce(reducer, initial=None)

Call the reducer on each node accumulating over the result.

reduce_to(path, reducer, initial=None)

schema_keys = {'_default', '_emit', '_properties', '_serializer', '_updater', '_value'}

schema_topology(schema, topology)

Fill in the structure of the given schema with the values located according to the given topology.

set_value(value)

Set the value for the given tree elements directly instead of using the updaters from their nodes.

state_for(path, keys)

Get the value of a state at a given path

top()

Find the top of this tree.

topology_ports(schema, topology, source=None)

Distribute a schema into the tree by mapping its ports according to the given topology.

topology_state(topology)

Fill in the structure of the given topology with the values at all the paths the topology points at. Essentially, anywhere in the topology that has a tuple path will be filled in with the value at that path.

This is the inverse function of the standalone inverse_topology.

update_subschema(path, subschema)

Merge a new subschema into an existing subschema at the given path.

class vivarium.core.experiment.TestUpdateIn

Bases: object

d = {'bar': {'c': 'd'}, 'foo': {1: {'a': 'b'}}}

test_add_dict()

test_add_leaf()

test_add_to_root()

test_complex_merge()

test_set_root()

test_simple()

vivarium.core.experiment.always_true(x)

vivarium.core.experiment.assoc_path(d, path, value)

vivarium.core.experiment.dissoc(d, removing)

vivarium.core.experiment.generate_state(processes, topology, initial_state)

vivarium.core.experiment.get_in(d, path, default=None)

vivarium.core.experiment.identity(y)

vivarium.core.experiment.inverse_topology(outer, update, topology)

Transform an update from the form its process produced into one aligned to the given topology.

The inverse of this function (using a topology to construct a view for the perspective of a Process ports_schema()) lives in Store, called topology_state. This one stands alone as it does not require a store to calculate.

vivarium.core.experiment.invert_topology(update, args)

vivarium.core.experiment.invoke_process(process, interval, states)

vivarium.core.experiment.key_for_value(d, looking)

vivarium.core.experiment.make_proton(parallel=False)

vivarium.core.experiment.normalize_path(path)

vivarium.core.experiment.pf(x)

vivarium.core.experiment.pp(x)

vivarium.core.experiment.schema_for(port, keys, initial_state, default=0.0, updater='accumulate')

vivarium.core.experiment.test_in()

vivarium.core.experiment.test_inverse_topology()

vivarium.core.experiment.test_multi()

vivarium.core.experiment.test_parallel()

vivarium.core.experiment.test_recursive_store()

vivarium.core.experiment.test_sine()

vivarium.core.experiment.test_timescales()

vivarium.core.experiment.test_topology_ports()

vivarium.core.experiment.timestamp(dt=None)

vivarium.core.experiment.update_in(d, path, f)

vivarium.core.experiment.without(d, removing)