Analytical jacobian and rate derivative.
Change rate derivative function to return an array derivative for all reactions
Perform direct local sensitivity calculation within dassl solver if turned on

Should be adaptable for additional reaction systems other than the
isothermal/isobaric system SimpleReactor.  Each new reaction system will need
an analytical jacobian and rate derivative function.
Created new class-based implementation of the VF2 algorithm.

The use of a class lets us store some variables as attributes, so we don't
have to keep passing them around as parameters. It also offers a cleaner
API that encapsulates the details of calling the algorithm inside the
class.

I don't expect a significant speed change from this commit.
Fixed version of Molecule.getFormula().

The previous implementation would print a 1 for atoms that only appear
once in the molecule, e.g. C3H6O1 instead of C3H6O.
Added a few methods to make CanTherm easier to run from a script.

The common use case here is running CanTherm jobs and making custom plots
of the results, e.g. for a paper.
Fixed indexing bug in generateFullMEMatrix().

The bug was that the algorithm was trying to access the Fim value for
a product channel, which does not exist.
Added Network.solveReducedME() method.

This method takes the results from the MSC, RS, or CSE method and uses
them to compute the approximate total populations and population
distributions for a given set of time points and a given initial
condition (much like solveFullME() does).
Fixed scaling bug in computing of uij(E) and vim(E) via CSE method.

Amazing the things you find when trying to reproduce two-year-old
figures for your thesis.
Can now specify optional energy offset to network drawing algorithm.

This allows you to shift all of the wells up or down in energy on the
PES drawing, which is sometimes useful for setting one of the
configurations to have a ground-state energy of zero.
Merge branch 'master' of git://github.com/jwallen/RMG-Py
Merge branch 'jacobian'
In reservoir state method, use the deepest well to choose the matrix bandwidth.

We use a banded matrix in the reservoir state method to accelerate the
linear solve. The halfbandwidth of this matrix is chosen by neglecting
P(E,E') values below a certain threshold. It is important to choose the
deepest isomer well for this, as it gives the largest halfbandwidth and
therefore the safest banded matrix.

I noticed this issue in a PES where I had a very shallow adduct as the
first isomer well. Since the previous implementation used the first isomer
only to choose the halfbandwith, it was choosing a value that was far too
small for the other isomer well.
Implemented preliminary version of CSE lumping algorithm.

The lumping algorithm applies when you are deficient by at least one
reaction timescale due to blending into the collision timescales. It
eliminates one or more isomer wells from consideration and returns the
subset of the k(T,P) values for the remaining configurations. This might
be useful for investigations of individual networks in detail.

The priority of lumping is indicated with the lumpingOrder parameter;
probably you want to lump the shallowest isomer wells first most of the
time. (Think pseudo-steady state approximation, not rapid equilibrium
approximation.) If the lumping order is not specified, or if the list is
too short to account for all of the missing eigenmodes, the CSE method
fails as before.

I don't know if there is a good way to "unlump" to fill in the missing
k(T,P) values.
Fixes to mapDensityOfStates() and mapSumOfStates() for adiabatic J-rotor.

This function now actually works with activeJRotor = False (i.e. for
solving the 2D master equation).
Some refactoring of the k(E) consistency check.

In the new implementation, kf0 and kr0 should give the same value in both
the RRKM and ILT modes. This way, the equilibrium constant is given by
Qprod / Qreac (formerly Qr / Qf) as expected.

The previous check was working fine; this is just a bit clearer as to
what is actually going on.
More fixes to mapDensityOfStates() and mapSumOfStates() for adiabatic J-rotor.

Was missing the degeneracy in both the unimolecular and bimolecular
versions. A factor to allow for J spacings greater than one was also
needed.
Fixed SingleExponentialDown.generateCollisionMatrix() for P(E,J,E',J').

The previous implementation was not properly filling in the values for
P(E,J,E',J') at each J and J'.
Merge branch 'master' of git://github.com/jwallen/RMG-Py