Define state2aa properly.

Implement write_mod and esc_all for non-epitope WF run.

Conflicts:
wf.cpp

Numerical stability modification to sigmoid function (for survival probability).

Merge commit 'c6cabec'

Cosmetic changes to comments, format, and spacing.

Conflicts:
wf.cpp

Implement write_mod and esc_all for non-epitope WF run.

Make only `wf` (Wright-Fisher code).

Numerical stability modification to sigmoid function (for survival probability).

Cosmetic changes to comments, format, and spacing.

Remove two-site Hamiltonian.

:retab (replace \t with normal whitespace).

Rescale rates by system volume ratio (parameter).

CTL killing reactions are smart about virus-changing reactions (by tracking last-changed species).

Recalculate differently based on what reaction caused propensity "change" (currently: does not matter).

Test script for Potts code.

Clean up extra debug printing.

Fix some dependents. Modify total propensity instead of totally re-sum.

Handle dependencies between reactions, only recalculating propensity when affected. Tons of extra debugging stuff.

Option to print trajectory every N steps.

Allow passing script names into unit test runner. (Default: all *.test files.)

Unit testing for Ising using compensatory landscape from Krishna (not his RC_fun though).

Copy constructor for Virus and NTVirus object to reduce unnecessary energy calculations.

Fix subtle rare bug involving next timestep = infinity. Also prevent first rxn firing with zero propensity.

Firing the viral growth/death reactions should probably iterate over the entire map container....

Terminally differentiated effector cell needs additional death term. RC_fun = exp(-E) to match SSC.

ctags -a -R

Reactions accounting for propagation of CTL divisions.

Framework for multiple divisions (i.e. generations) of effector T cells.

Swap M and T in setting up CTL reactions (Ising).

Set up reactions for CTLs recognizing amino acids.

Import Potts epitope (amino acid sequence). Helper split() function on arbitrary delimiter.

Save mapping of Potts state to amino acid as well. Virus object has no access though.

Initialize distribution of nt seqs from file. Print (aggregate) unique amino acid seqs.

Start runtime framework for executing Potts system. Break out initialization routine.

Fix the build: delete all the temporary testing stuff.

Define all the reactions for Potts virus, handling nucleotide-level mutations.

Map the nt enum to and from character representation.

Construct recognizer from epitope string (and starting location).

CTL for recognizing arbitrary amino acid sequence as epitope.

Potts state mapping+tracking complete. Fix bounds check error in energy calculation.

Significant speed-up by inlining GSL RNG functions (~20% in short tests).

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.