Copy over code to read seq2state file, which gives amino acid identity of each Potts state.

Start of Potts / amino acid / nucleotide-based virus species.

Avoid multiple defs of translators by only declaring in header. Now const, so must use .at(), not [].

Scrap enum class definitions. Clean up seqTools.

Copy seqTools.cpp to seqTools.h for inclusion to main.

Break normal functionality for testing! Separate beta (inverse temperature).

Solve warning about comparison between signed and unsigned integer expressions.

Copy John's Potts code from snip.{cpp,h}.

Decipher Potts encoding of sequence state/configuration.

WF: correctly use init pop frac.

Testing nucleotide <-> amino acid translation. Needs C++0x.

Compile with:
  g++ -std=c++0x -o seqTools seqTools.cpp

Remove mutation rate "mu" from Virus object; now exclusively in reaction.

Update Makefile with header dependencies.

Multiple runs, more rate args, end simulation when all reactions exhausted.

Print virus species sequence when verbose.

Formatting: retab, clean whitespace.

Delete unused functions for SS.

Clarify dependencies. Copy hamiltonian.{cpp,h} to ham_ss.{cpp,h}. Copy contents of virus.{cpp,h} into pop_ss.{cpp,h}.

Virus reproduction reaction stores its own mutation rate.

Free memory from species and reaction arrays (to satisfy some valgrind).

Proper species names. Initial counts CTL counts for each type.

Output at intervals, remove more WF.

Clean out WF-only stuff.

Full system, including parameters.

Initialize multiple CTL clones+epitopes. Output at intervals. Pretty-print the sequence.

Separate function for running the dynamics.

Framework for killing by CTL.

Flesh out reactions for virus reproduction (with mutation) and death.

Start of Gillespie test.

ctags -a -R

ctags

Code to read Potts coupling parameters and calculate energy, from John Barton 20150218.

Actually do (and document) multiple runs without epitope.... And use initial population fraction....

(cosmetic) Personalized RunParameters for stochastic Gillespie simulation (SS).

Monte Carlo simulation of Boltzmann-distributed energy. Start Gillespie code. More build rules.

Fix sorted_vector compile errors (presumably due to gcc vs MSVC differences).

STL compliant sorted vector class (std::map replacement) from CodeProject.

Source:
http://www.codeproject.com/Articles/3217/An-STL-compliant-sorted-vector?display=Print

Introduction:

sorted_vector adapts a std::vector to the interface required by
std::set/std::multiset, thereby providing set/multiset and vector
functionality (random access) in one container.

Tests show that sorted_vector's element retrieval (find) speed
outperforms that of std::set/std::multiset by a factor of 2 (on most
machines). On the downward side is the poor performance of
sorted_vector's insert member function, because it inserts an element
somewhere in the middle of the sorted vector in order to preserve the
sort order. By using sorted_vector's low level interface one can solve
this performance bottleneck by inserting a bunch of objects using a
series of push_back's followed by a call to the member function sort,
which restores the sort order.

sorted_vector should be preferred over std::set/std::multiset if many
small elements must be stored. Most STL implementations use a variant of
a balanced tree to implement set and multiset, which imposes a per
element storage overhead of 3 pointers. The most important reason to use
a std::set/std::multiset instead of sorted_vector is the need to keep
iterators into a set/multiset while inserting more elements into the
set. These iterators remain valid in the case of a set/multiset, but are
invalidated in the case of a sorted_vector container.

Command line parameter for bonus/penalty applied to each epitope or total immune pressure.

Print supplementary output file (*.sum) with CSV sequence.

Detect when escape from *all* epitopes (vs *any* immune pressure).

GSL {headers,libraries} on lc2 are in default search path: {/usr/include,/usr/lib64}.

Allow calculating energy without including epitope bonus.

Update unit tests. Add new one with simple two-site parameters.

Print sequence as CSV (comma-separated).

Update unit tests.

Spread total immune pressure strength uniformly over targeted epitopes.

Start of Monte Carlo (static epitope calculation), copy WF code.

Don't fflush population-writing each time.

Print generation number on each line. (Need to update unit tests.)

Test all one- and two-epitope cases of WT/mut site combinations.

More comprehensive test framework.

Correctly parse multiple epitopes per file (using C++ streams), regardless of WT/mut.

Unit test for multiple-epitope input file.

Multiple epitopes; one per line in .ep file. All have same penalty for now.

Use '|' as epitope mut/WT field list separator (on single line).

Update unit tests for separate .st and .ep files.

Read population state and epitopes from separate files.

Extra output and tests for debugging.

Start framework for targeting multiple epitopes.

Basic unit testing framework.

Check for file-opening / existence errors (vs segfault). write_mod for general Hamiltonian. --help flag.

Add write_mod option to write population at regular time intervals (two-site/two-allele only).

Locate segfault for small N (population size = 0). Seed as additional run parameter. Concatenate source files?

Special two-site + two-allele (two-locus + binary) Hamiltonian with all parameters passed as command line arguments.

More output for non-epitope runs. Assuage compiler warnings of unused parameters and signed/unsigned int comparison.

Wright-Fisher code by Tom Butler (via John Barton).

Just use the GNU Scientific Library (GSL) for RNG. (But also include my attempt at copying over the relevant bits.)

Add Mersenne Twister RNG library/header. Generalize to stream<< any std::map<T> as CSV-like string.

Print mutset_t (to stream using operator<<) as CSV-like string.

Start of Wright-Fisher dynamics using STL. Mutations stored as std::set, species counts in std::map.