Make chemkin parser case-insensitive to keywords.
Use species label when saving rotor scan plots in CanTherm jobs.

This enables the user to have multiple species in the same directory, but
still keep the plots of the hindered rotor scans.
Fixed bug in unit conversion when plotting kinetics in CanTherm jobs.

Had a multiplication where a power should be, causing the k(T) to become
zero for unimolecular reactions.
Merge branch 'patch-1' of https://github.com/jbarlow3/RMG-Py
Merge remote-tracking branch 'official/master'
Moved unimolecular and bimolecular family names to rmgpy.data.kinetics.common.

In anticipation of these being used by multiple modules. (I'd rather they
weren't needed at all, of course, but currently they are used when reading
and writing the old database to get the appropriate units.)
Moved KineticsGroups class to new rmgpy.data.kinetics.groups module.

The rmgpy.data.kinetics.family module is still rather long, and I think
there is (or will be) enough specialized group additivity functionality
to warrant its own module.
Moved UndeterminableKineticsError to rmgpy.data.kinetics.common.

As it is now shared across multiple submodules of rmgpy.data.kinetics.
Created new KineticsRules class for storing kinetics rate rules.

There's enough specialized functionality that it warrants its own class,
distinct from KineticsDepository. The current implementation is largely a
copy of KineticsDepository, with a few small method name changes.

The KineticsRules class has been placed in a new module
rmgpy.data.kinetics.rules.
Removed rate rule functionality from KineticsDepository class.

This has all been moved to the KineticsRules class. The remaining
KineticsDepository class is much smaller (and more indicative of its
current use).
Moved some rate rule functionality from KineticsFamily to KineticsRules.

Now that we have a KineticsRules class, we can collect the functionality
for working with rate rules in that class. This includes methods for
getting rate rules, estimating kinetics, and filling in rate rules by
averaging up.
Entries in KineticsRules now grouped by template.

For a given template, you no longer need to iterate over all of the
entries to find the possible duplicates for that template. Instead, you
can get the entire list directly using the template as the key to the
entries dict. To get the entire list of values as before, use the new
KineticsRules.getEntries() method.
KineticsRules.getRule() now returns None if no rule is found.

This is for speed. When we are filling in the kinetics rate rules by
averaging up, we use getRule() a lot to check if rules exist. When they
didn't exist before, a ValueError was raised, which was quite expensive
because it occurred so frequently. This change causes a significant
speedup in the filling in of the kinetics rate rules.

Note that KineticsFamily.getRateRule() still raises ValueError when
KineticsRules.getRule() returns None.
Some refactoring of KineticsFamily.getKinetics().

The rate rules search is now handled separately from the depository
searches. A few helper methods getKineticsFromRules() and
__selectBestKinetics() were added to keep getKinetics() from becoming too
long and to minimize duplicate code.
Merge branch 'database'
Added checking of common units when parsing rate coefficients.

We've used this trick with other unit types to get a speed boost, but we
had forgotten to include it with the special case of the rate coefficient.
Since this is an extremely common unit type to parse in RMG, I expect this
change to come with a noticeable speed boost for a few areas.

Note that I've only added unimolecular and bimolecular rate coefficient
units, as other molecularities are too rare to be worth it.
Cp0/Inf saved on thermo, should load if already generated.
Fixed crash when QM not requested
Some refactoring of KineticsFamily.__generateReactions().

This refactoring is intended to speed things up a bit by reducing the
number of calls to generateResonanceIsomers(). To accomplish this, the
steps of removing reactions that don't match a given set of products
and combining reactions that give the same products are once again
performed separately.

The refactored algorithm also removes some duplicated code.
Some Cythonization added to Molecule.generateResonanceIsomers() et al.

We do this often enough that we want to make it as fast as possible.