This action still uses topology.cells, which doesn't exist. Move to using the topology.graph.

Create an environment variable (e.g. $SEEDSPLUGINPATH) that stores the seeds plugins. Although this can be specified in a config file, it'd be nice for someone to have their own global repository of plugins.

Then programs like runseeds.py could just use that. Perhaps iter would return the epoch number.

This would update the population as long as proceed was true. At the end, teardown() could be called to do the cleanup.

To allow experiments in traditional style well-mixed populations, create a well-mixed topology.

This could be done as either a graph with no edges. The topology would have to overwrite the basic Topology get_neighbors method and return a list of randomly-selected neighbors. The number of neighbors would be a parameter.

A second option would be a complete graph. This would also require a parameter to define the size of the neighbor list (pick a subset of the nodes randomly). The big downside is that this would prohibit large populations, as a complete graph takes a lot of time and memory.

For those Actions which write files, specify whether or not to write a header row.

Actions that do not write files can ignore this option.

Just like user plugins, the included Cells, Topologies, and Actions should be included in a system (i.e., installed where SEEDS is installed) plugins folder which is automatically appended/prepended to the plugin_dirs.

I'm on it...

This is what I'm thinking. We need a high but narrow peak, and a wide but lower second peak. Maybe 10 bits, the first 3 bits are the high but narrow peak, where having only these bits turned on allow you to be on the peak. Having 1 or 2 bits would be less fit than having 3, but any of the other 9 bits on would move you to a lower fitness. The other 6 bits could be additive and require you to not have any of the first 3 bits on. The highest fitness you can have in the 6 later bits would have to be less than having all 3 first bits on.

Allow Actions, Cells, Topologies, and even Resources to execute a teardown() function.

Actions (e.g. WriteSnapshot) could have a write_on_teardown parameter that would write data at the end of a run.

Causing breaks whenever you define resources in the config file

It would be nice to ignore nodes entirely in the code, and if people need to get neighbors of a cell, for infection, or game theory stuffs, then you have to pass the node in. Instead we should pass a cell, and since the base Cell class knows its node, it can reliably access this variable and abstract the whole node business away.

Add an optional 'type' argument to get_plugin to specify the type of the plugin to retrieve (e.g., Cell, Topology).

Create an Action that writes a Snapshot

Also create one that loads and applies a Snapshot?

Add a parameter that specifies what the size of the lattice is that will specify the resource across space.

1 = global resource (default??)

Nodes represent organisms, and links between them represent potential interactions. Resources in the environment, however, don't need to follow those rules. Additionally, this allows Cells to create/remove/modify links by choice and still have the same environmental conditions.

Implement outflow of resource into neighboring nodes in NormalResource.

Create a Cell type that would allow for Prisoner's Dilemma and Snowdrift like experiments. Configured parameters would be Temptation, Reward, Sucker's Payoff, and Punishment.

Headers should be uncommented. Check if they have to be in the first line, or if they can be preceded by comments.

To allow for Topologies in Resources and Populations and to prevent separate systems for both, topologies should simply create graphs. Resources or Populations could then take these graphs and add a Resource or Cell as an attribute, accordingly.

In the distance calculation, we calculate the square root every time we do a comparison. Instead pre-compute radius^2, and just compare to that. This is a constant speedup, but a fairly important constant. Also, it appears that math.sqrt() is about 7% slower than just calling "from math import sqrt()", not sure if its just some overhead in importing the package. Maybe python is smart enough to unroll the above comparison properly, I'm not sure, but its something work looking into.

This has its pros and cons.

Done. Still need to fix PrintCellTypeCount, which creates a cell in order to get the type names. May be a better way to do this. Perhaps create a self.cell_type_ref in World.

Traceback (most recent call last):
File "runlettuce.py", line 116, in
main()
File "runlettuce.py", line 76, in main
world = L.World(configfile=cmd_options.configfile, seed=random_seed)
File "/Library/Frameworks/Python.framework/Versions/6.3/lib/python2.6/site-packages/lettuce/World.py", line 61, in init
self.topology_manager = TopologyManager(self)
File "/Library/Frameworks/Python.framework/Versions/6.3/lib/python2.6/site-packages/lettuce/TopologyManager.py", line 52, in init
t = CartesianTopology(self.world, topid)
File "/Library/Frameworks/Python.framework/Versions/6.3/lib/python2.6/site-packages/lettuce/topology/CartesianTopology.py", line 80, in init
periodic_boundaries=self.periodic_boundaries)
File "/Library/Frameworks/Python.framework/Versions/6.3/lib/python2.6/site-packages/lettuce/topology/CartesianTopology.py", line 148, in build_graph
p_coords = G.node[potential]['cell'].coords
KeyError: 537

Things that get used often like mean(), std(), etc. should be placed in a file that can be imported when used. This will cut down on duplication and hopefully make it easy for developers to find commonly-used functions.

Add a set of actions to deal with Resources (in the generic sense), such as making them available or unavailable.

Add an option to Action to specify whether or not the Experiment's UUID should be included in CSV files. This would allow results from multiple Experiments to be concatenated.

This might also make parsing CSV files a little more tricky for scripts that do plotting, for example.

Allow runseeds.py to listen for kill signals or other signals used for preemption on queueing systems, and write a snapshot.

We could write a PrintPopulationAttributes and a PrintCellAttributes action, each which can register plugins that either take the population in and return a single (comma-free) value, or take a single cell in and returns a single value. The idea being you can have a single csv file that prints many population values (like cell types, average vals) and another csv that prints cell properties (like xy cords, type, prob of cooperation). This would probably cut back on some effort in writing some common types of print actions.

This will allow actions like WriteSnapshot to be executed last, or LoadSnapshot to be first.

Add a layer that would allow actions to seamlessly write to either a CSV file or to a sqlite database.

This would be implemented as a wrapper that writes in whichever way the configuration file says.

Make all of this a plugin. Can remove code from World.

Give runseeds.py the ability to create an archive of the version of SEEDS used and any plugins. This will greatly help in making data public, as it allows people to re-trace an experiment exactly.

World doesn't make a whole lot of sense, and its config items are in the [Experiment] block anyway.

Add an optional 'type' argument to get_plugin to specify the type of the plugin to retrieve (e.g., Cell, Topology).

Since this is NormalResource specific, name it something that reflects this.

Instead of a few different predefined Resource types, make these plugins as well.

Open question: should all resources be based on a lattice, or should this be open? Pros/cons either way.

Makes sense to have these handy...

Optparse is depricated, so move to argparse.

At the moment, it assumes the header is commented. This is no longer the case.

In addition to a 'standard' resource type with inflow and outflow, add things like "sine" with period and amplitude and maybe "sawtooth".