API for Ksolve implementation

Introduction.
This part of the MOOSE documentation describes how fast linear algebra 
solutions of chemical reaction networks are carried out. The equations are
a system of nonlinear ODEs defined as follows:

dS/dt = N.v

where S is the vector of molecule concentrations
N is the stoichiometry matrix defining the reaction system, and v is the
rate vector, that is, the vector of rates of each reaction in the system.
The rows of N are molecules, and the columns are reactions.

Numerics
The actual calculations in the Ksolve are done using the GNU Scientific
Library, GSL. The GSL offers a number of numerical methods, most of which
are available to the Ksolver. The adaptive timestep Runge Kutta method rk5 
is usually a good choice.

Other roles ofthe Ksolve system
Other than the calculations, the key role played in the Ksolve is to interface
between the Element and message-based model structure definition, and the
contents of the various matrices and vectors that do the number crunching.
This is in two phases:

Setup: Here the ksolve system has to scan through the reaction system to build
up the stoichiometry matrix and calculation rules for the rate vector.
Runtime updates: Here the Ksolver has to respond to any requests from the 
MOOSE model structure for getting or setting values in the reaction sytem.

In addition there are various elaborations for handling interfaces to other
solvers and numerical engines, such as Smoldyn and the SigNeur system.


=============================================================================

System overview

Classes:
Stoich: Manages the data structures in the simulation. Specifically,
	molecule vector 			S
	initial conditions 			Sinit
	Reaction velocity vector 		v
	Stoichiometry matrix 			N
	Vector of rate terms 			rates
	Vector of function terms 		funcs
	Mapping from the Ids to S, rates, funcs	objMap

	Also has key functions:
	Set up the model			setPath()
	Update the reaction velocities		updateV()
	Reinitializes conditions		reinit()
	Note that process() is a dummy function.



GslIntegrator:	Numerical engine for Stoich, using the GSL.
	It has a few simulation control parameters
		method
		accuracy
		stepsize
	and it has a pointer to the stoich_ class.
	It also holds internal data structures for GSL.

	It does the actual calculations in the function: 
		process


KinSparseMatrix: Efficiently holds the stoichiometry matrix.
	Derived from SparseMatrix< int >
	Provides efficient compute operations for getting dS/dt from the 
	molecule vector and the reaction velocity vector.
	It has some hooks for doing Gillespie type calculations too.

RateTerm: Base class for a large number of derived classes which compute
	derivatives for various kinds of reactions, like enzymatic, 
	reversible, and so on. Looks up molecule amounts by their indices in
	the Stoich::S vector.

FuncTerm: Base class for assorted derived classes which compute
	functions based on molecule arguments looked up by their indices.


Zombie classes:
	These are all derived from the Stoich, and have no C++ fields of their 
	own. Instead they have the MOOSE fields of the class that they
	are taking over. 

	At setup, the 'zombify' function takes all the relevant parameters
	from the original object, puts them into the Stoich, and replaces
	the 'data' part of the original object with the Zombie version.
	Thus all the original messages and Ids are unchanged.

	There is an 'unzombify' function which supposedly does the reverse,
	but it hasn't been rigorously tested.

	In operation, all fields and functions of the zombified class are 
	handled by accessing the corresponding Stoich fields.

=============================================================================
