CHANGES.txt

V0.1.17, October 2015 --
   . Updated the K_salt values for O2, N2, and Ar with data from Weiss (1970).
   . Changed the way simulation results are saved to the netCDF format files
     so that whether or not the user provided external chemical properties 
     data and whether or not the user provided the delta_groups variable, the
     save/load commands figure out what was done and do the right things.  In
     past versions, the user had to tell the load command what the user_data
     and delta_groups variables were.  This is no longer required.
   . Updated the bent plume model save_sim and load_sim methods so that if
     the particles are tracked in the farfield, the tracking solutions are
     saved.
   . Updated the save_txt methods for all models so that they are called 
     the same way and to ensure that all data in the state space is reported
     properly in the header files.
   . Updated all ./bin examples to ensure they are compatible with the present
     model version.
   . Changed the criteria for convergence for the stratified plume model.  
     Added a check for the trap heights, peel heights, intrusion layer flux, 
     and inner plume volume flux at the base of each peeling region.  Kept
     all of the former criteria on maximum flow rates and momentum fluxes.
     Removed the criteria that the volume flux at the top of the plume should
     match between simulations; this is replaced by the volume flux checkes
     for each peel.  The new criteria seem to be consistent with previous 
     versions (i.e., equally stringent), but more stable--these criteria are
     now fixed to plume features and not fixed depths.
   . Updated the bent plume model so that currents can come from any direction
     and can change direction during a simulation.  This allows the model to 
     accept velocity profiles with three-dimensional currents.  Add the 
     currents to the ambient profile object as 'ua', 'va', and 'wa'; note 
     that z is positive down so that upwelling is a negative vertical 
     velocity.
   . Updated the test cases of the bent plume model so that the tests are 
     comprehensive.  Previous test files had a place-holder for the bent
     plume model, but without any tests.  
   . Replaced the from numpy.testing import * command with more specific 
     imports that only grab the functions used.  These commands were in the 
     test files and invoked the nosetester.py test.  The edit makes it so 
     that the nosetester.py test is no longer executed when importing from 
     numpy.testing. 
   . Updated the p_fac calculation for the bent plume model Particle object
     to give the best match with the experimental data in crossflows.
   . Updated the initial guess for the Kvsi method for the discrete bubble
     model hydrate stability calculation to work better at lower pressure.
V0.1.16, September 2015 --
   . Fixed the way the model keeps track of particles that exit the plume.  
     The solution from the previous version of the model is not changed, but
     the way the flag is handled was updated so that there will be no 
     conflicts in post-processing the solution using the LagElement.update()
     method.
   . Updated the bent plume model so that it stops at the second neutral 
     buoyancy level for a stratified case.
   . Updated the dbm.equilibrium calculation so that the method works even if
     first several elements of the mass vector has zero mass.
   . Updated the dbm.equil_MM function so that it is much faster if 
     successive_substitution is finding single-phase tendency without 
     converging:  stability analysis is initiated sooner, which solves the 
     issue.  
   . Added a new parameter to the dbm.FluidMixture and dbm.FluidParticle 
     object creator called sigma_correction which can specify the value of
     the interface tension from a measurement divided by the value of the 
     interface tension given by the default model.  This capability is 
     recommended for use by the interface tension equation developer to 
     adjust the model for measured data when available.
V0.1.15, August 2015 -- 
   . Changed the way the bent plume model tracks the particles inside the 
     plume.  Previous versions did the particle tracking outside the main 
     integration loop.  This has two problems:  1.) the adaptive step solver
     used in the main integration does not know when particles leave the 
     plume, so there can be a big integration step near where particles 
     leave even though this should be a small step (solution is to set a 
     reasonably small value of dt_max, but this defeats the benefit of the
     adaptive step solver).  2.) this reduces the accuracy of the particle
     tracking since it is not down inside the RK adaptive step solver and
     can only rely on plume solutions at two final time steps.  The new 
     version of the model does all particle tracking inside the main 
     integration loop.  Particle time and position relative to the plume 
     centerline in local plume coordinates (unit vector direction l,n,m in 
     Lee and Cheung (1990)) are added to the plume state space.  The old
     outputs tp and sp are removed from the model.  Conversion of the 
     state space solution to x,y,z Cartesian coordinates is handled by the
     LagElement object.  This new method has a smooth transition when 
     particles leave the plume.
   . Solutions for tp and sp have been removed from the bent plume model 
     as discussed above.  These are now available through the LagElement
     object as a translation from the plume state space.
   . The entrainment function for forced entrainment was adapted to prevent
     errors in large crossflow.  If the integration step (ds) compared to the 
     plume width is small (ds/b < 1.e-9), we neglect the expansion and 
     curvature corrections to the forced entrainment.  Otherwise, the 
     entrainment will go to infinity unrealistically due to numerical problems
     in estimating db/ds from two model solution points.
   . Changed the bent plume model state space to have total particle mass 
     in the Lagrangian element (M_p = m * nbe) instead of mass flux.  This
     is more consistent with typical Lagrangian plume models.
   . Changed the bent plume model state space variable for concentration of
     dissolved-phase tracers to be total mass of tracer in the element 
     instead of the concentration times mass (C*M) typically used.  Salinity
     and passive tracer are still modeled in the old way (psu*M, C*M).  This
     new formulation makes it much easier to add the dissolving particle
     mass to the dissolved phase inside the Lagrangian element.
   . Updated where the buoyant force reduction factor (p_fac) is calculated.
     p_fac accounts for the fact that the buoyant force from the bubbles
     decreases as the particles start to drift out of the plume.  This is
     now with the new particle tracking.  Older versions had errors due to 
     the phase shift between the current model solution and the particle 
     tracking, which was conducted outside the main integration loop.  The 
     new method has consistent tracking so that phase errors do not give the 
     wrong p_fac.
   . Updated the hydrate formation time with refined calibration values and
     ensuring that the formation time cannot be negative.  Also, note that 
     if hydrate_formation_time is used and the bubble starts above the 
     hydrate stability zone, clean bubble mass and heat transfer will be 
     assumed throughout the model simulation.
   . Updated chemical_properties.py to make it compatible with older versions
     of Python.  
V0.1.14, July, 2015 -- 
   . Changed the stratified plume model inner plume entrainment coefficient 
     to match that in the bent plume model.  The bent plume model had a more
     sophisticated treatment of the shear entrainment that matches approaches
     in single-phase flow, allowing the entrainment coefficient to depend on
     the local plume Froude number.  This was facilitated by moving the 
     function to compute the shear entrainment from lmp.py to 
     dispersed_phases.shear_entrainment.  The function is then called as 
     needed by the bent plume and stratified plume models.
   . Checked the stratified plume model validation against data in Socolofsky
     and Adams (2003, 2005).  Verified that the new entrainment model is 
     acceptable and that the performance matches that in Socolofsky et al. 
     (2008).  Also, verified that the present treatment of gamma_i and gamma_o
     in the stratified plume model (which matches what was used in 
     Socolofsky et al. (2008), but not the equation written in the text) is
     the optimal usage.  Hence, the stratified plume model is fully validated
     to match or exceep performance of the model in Socolofsky et al. (2008).
   . Checked the bent plume model validation against data in Milgram (1983)
     The no crossflow cases in Milgram perform well. Also, verified that the
     stratified plume model and bent plume model give equal results for the
     quiescent, unstratified cases in Milgram. The only model deviations are
     for results very close to the diffuser in the z/D space defined by
     Bombardelli et al. (2007), and since the diffuser geometry is unknown,
     these deviations are accepted.
   . Checked the bent plume model validation against data in Socolofsky and
     Adams (2002).  This showed that the crossflow separation height was
     over-predicted by the model.  This is because the full buoyancy of the 
     bubbles is exerted on the plume until they reach the plume edge.  To 
     solve this, we now reduce the bubble buoyancy by a factor 1 - lp/b, 
     where lp is the distance from the centerline of the plume to the 
     bubbles and b is the plume half-width.  Tried other forumlations, 
     including (1 - lp/b)^2 and exp(-lp**3/b**2), and the simple linear 
     model gave the best match to data in Socolofsky and Adams (2002).  
   . Included the particle age and position as an attribute of the bent plume
     model `Model` object.  
   . To compute the buoyant force of the bubbles with the new crossflow 
     factor, had to add sp (particle position) to the LagElement.update
     function.  This required sp to be passed to `lmp.calculate` and used
     in the `lmp.derivs` functions.  This will cause any old code to fail that
     tries to update the `LagElement` object without passing sp.  Since sp is
     an attribute of the bent plume model `Model` object, though, it will be
     easy to edit old code to have this added.  This only effects user-defined
     post-processing:  All old codes will still run to obtain the solution 
     and to plot it using the built-in plot_state_space or plot_all_variables
     functions.
   . Updated `lmp.calculate` with the `lmp.correct_temperature` function so
     that the particle temperatures are stored correctly.  The 
     correct_temperature function was distributed with previous versions of
     the model, but was not implemented in the `lmp.calculate` function so 
     that it was ineffective.  It is now turned on. \
   . Edited the initial conditions file for the bent plume model in 
     `lmp.bent_plume_ic` so that Q = Qj instead of Q = Qj + Qp since the 
     momentum equation assumes the void fraction is small.  With this change, 
     the initial half-width of a bent plume model simulation matches the 
     radius of the diffuser; moreover, the simulation result from the bent
     plume model is nearly identical to the result from the stratified plume
     model in quiescent, unstratified conditions.
V0.1.13, June, 2015 --
   . Updated the numerical solution for the bent plume model so that the 
     temperature is stored correctly once heat transfer is turned off.
   . Added the particle age (t_p) to the state space of the stratified plume
     model.
   . Added the hydrate formation time `t_hyd` to the 
     `dispersed_phases.SingleParticle` object and implemented the model from
     Jun et al. (2015) that the slip velocity and heat and mass transfer 
     should be for clean bubbles for t < t_hyd and for dirty bubbles 
     otherwise.  This also makes the particle age `t` and input to 
     `dispersed_phases.SingleParticle.properties`.  Because the 
     `SingleParticle` object is inherited by the stratified plume model 
     and the bent plume model particle objects, they also have this same
     behavior.  Added the correct coding to pass the computed particle
     ages in all of the relevant `update` methods.  Hence, `t_hyd` must 
     be set when creating a particle object and then the Jun et al. (2015)
     model is implemented automatically.  Set `t_hyd = 0.` to have the 
     dirty bubble solution or `t_hyd = np.inf` to have the clean bubble
     solution over the whole simulation period.
   . Added the method `dispersed_phases.hydrate_formation_time` to compute
     the hydrate formation time following the algorithm in Jun et al. (2015).
     Pass that formation time to the particle object at creation to use the
     hydrate skin model.  See `./bin/sbm/seep_bubble.py` for an example.  
     Implementation would follow the same process for the stratified plume
     model or the bent plume model.
V0.1.12, June 23, 2015 --
   . Replaced the methods to compute gas-liquid equilibrium with more stable
     and robust methods from Michelsen and Mollerup (2007).  For cases in the
     two-phase region, far away from the phase boundary, the new methods give
     identical results to previous versions of the model.  As the two-phase
     mixture approaches the phase boundary, the new methods prevent troubles
     associated with converging on the gas-liquid partitioning.  Outside the
     two-phase region, the new methods also give the same results as before, 
     but using far fewer iterations.
   . Replaced the methods to compute viscosity with equations from Pedersen
     et al. (2014).  These methods are less expensive (an equilibrium 
     calculation is not required) and give reasonable results for light oils
     and for gases.
   . Updated the dbm.py classes so that clean and dirty bubbles are handled
     consistently throughout.  Also, edited the dbm_phys.f95 file so that 
     spherical and ellipsoidal bubbles and droplets are handled separately 
     in all cases.  For clean bubbles, three mass transfer methods are 
     provided for spherical or ellipsoidal particles:  Kumar and Hartland, 
     Clift et al., and Johnson et al.  For clean gas bubbles, the greater of 
     Clift et al. or Johnson et al. is returned; for clean liquid droplets, 
     Kumar and Hartland is used.  For dirty bubbles or droplets, we follow
     Clift et al.
   . Updated the seawater equations of state with more accurate methods for
     air/water surface tension and thermal conductivity from Sharqawy (2010).  
     The new method for thermal conductivity reports the value in W/(mK);
     whereas, previous versions of TAMOC used m/s, which is obtained by 
     k / (rho * cp).  To preserve the model equations, the rho * cp term 
     has been corrected in dbm.py so that beta (the heat transfer coefficient)
     still has units of m/s.
   . Add the Setschenow constant to ChemData.csv and updated 
     chemical_properties.py so that any columns added to ChemData.csv are 
     automatically read into the properties database.  They are not auto-
     matically added to the dbm objects, though, since Python requires all
     variables to be created explicitly.  Updated the dbm.py to use the data
     for K_salt from ChemData.csv if available or to estimate the value from
     Jonas's correlation equation.  The final K_salt is passed to the fortran
     files when computing the solubility.  
   . Updated the dbm objects with a flag called `air` to allow the user to 
     specify that the working fluid is not a hydrocarbon.  In that case, all
     of the methods work equally well as for hydrocarbon mixtures except for
     the interfacial tension.  When `air` is false (default value), the 
     correlation for hydrocarbons is used; otherwise, the air-seawater 
     surface tension is returned.
   . Added mass transfer equations for Re < 1.0 using Clift et al. (1978)
     equation 3-49.
V0.1.11, June 2015 --
   . Corrected the units for computing Vb in dbm.py for the Tyn & Calus 
     method.
   . Updated the parameters lambda_2 and epsilon in the stratified plume model
     to match the values in Socolofs et al. (2008) for the best validation to
     the available data.
   . Added a few more known values to the ./data/ChemData.csv file.
V0.1.10, March, 2015 --
   . Corrected the values for Vb in the ./data/ChemData.csv file.  These 
     values are used to get a temperature-dependent diffusivity needed to 
     compute the mass transfer coefficient for dissolution.  The values in 
     version 0.1.9 were at standard conditions; whereas, the equations need
     the molar volume at the boiling point.  Results from the model for 
     light gases now agree much better with the old values using the B and dE
     method.  
   . Updated test cases to pass with corrected diffusivity and mass transfer
     coefficient.  
V0.1.9, February, 2015 --
   . Updated the equations of state with several small improvements to make 
     the code more flexible (requiring fewer inputs or more readily available
     data), more accurate (small updates based on better parameterizations),
     and more complete (clean and dirty bubbles, most all simplifying 
     assumptions removed, and all parameter values included with the model).
     These updates were suggested by Jonas Gros, ETH Lausanne, Switzerland, 
     through his and Sam Arey's collaboration with the model.  Many thanks to
     them for helping improve the chemistry simulations in the model.
   . Added ./bin/ambient_append.py as an example of how to add new profile 
     data to an existing ambient.Profile object.  
   . Fixed several problems in the bent plume model.  Particle objects update
     correctly now in the LagElement class, the initial conditions no longer
     overwrite the initial particle mass flux, updated the particle tracking 
     to know where the surface is located and not to track particles that 
     never leave the plume, and fixed a mistake in local_coords where dt was
     used instead of the correct value ds.
   . Realized that in the bent plume model, dt is the travel time for the 
     entrained water, so the dissolution and heat transfer equations for 
     particles were wrong.  Solved this problem by passing dtp / ds from 
     the previous timestep to the derivs function.  This appears to work.  
     Also, added particle age to the tracking routine.
   . Fixed the computation of the buoyant force of the bubbles in the bent
     plume model for a multiphase plume.  Previous computation left out the
     mass of the displaced water, which significantly under-predicted the 
     buoyant force.  The current version of the model gives nearly identical
     results to the stratified plume model in quiescent, unstratified 
     conditions, with differences stemming from the fact that a Lagrangian 
     model cannot accurately incorporate the lambda_1 and lambda_2 spreading
     rates.
   . Fixed the seawater equation for viscosity (T is in deg C, not K).
   . Added clean particle empirical equations for slip velocity, mass 
     transfer, and heat transfer based on equations in Clift et al. (1978)
     and Johnson et al. (1969).  This is implemented in the dbm.py module; 
     the default returned values are for dirty particles (e.g., no change
     from previous model releases).
   . Changed the equation used to compute the diffusivity in the dbm.py
     module.  The new equation is from Hayduk and Laudie (1974) and 
     depends on the viscosity of the continuous phase and the molar volume 
     of the dispersed phase components at their boiling points.  These 
     values are more readily available than the parameters needed by the 
     previous equation for diffusivity.  This makes the model more flexible
     to handle a wide array of compounds.
   . Added new property to the dbm.py module:  viscosity.  These equations are
     generally true for gas and liquid hydrocarbons.  Other immiscible
     liquids would likely have large errors (e.g., water is off by three 
     order of magnitude).  This is needed for the clean particle mass 
     transfer equations; otherwise, it is not used by the model.
   . Made the commands in the chemical_properties.py module into a function
     so that they can be called with different ChemData.csv files.  Updated 
     dbm.py to use the new function to automatically load the ChemData.csv
     file that comes with TAMOC in the ./tamoc/data directory.  Also, added
     the capability in dbm.py for the user to supply an alternate database
     from another directory.  This new database will overwrite the data from
     the ./tamoc/data directory if the same component is present in both;
     otherwise, the new data is appended to create a larger database.  This
     is particularly useful when the user needs to use a pseudocomponent 
     model for a particular oil.
   . Added the capability to compute the temperature-dependent binary 
     interaction coefficients following Jaubert et al. 2005.  Two new files
     were added to the ./data directory:  Aij and Bij contain the group
     contribution method coefficients for the matrices A an B in the 
     Jaubert et al. 2005 paper.  To use this method, the user must supply
     a new input to the dbm object initializer called `delta_groups`, which
     gives the fraction of each group contained in each compound in the 
     mixture.  
v0.1.8, December, 12, 2014 --
   . Added the capability for the params.Scale object to print out the 
     solution to the empirical model equations and to save the results to 
     the hard drive.
   . Upgraded the entrainment calculation so that the shear entrainment is 
     never a large negative value (see Figure 13 in Jirka, 2004, for details).
   . Finalized the entrainment model with the corrected shear entrainment
     and correct asymptotic behavior
   . Fixed a bug where particle tracking stopped too early for some particles
     in the bent plume model.
   . Added bent plume model sample scripts in ./bin/bpm for a bubble plume
     (bpm_example.py) and for a blowout (bpm_blowout.py).
v0.1.7, November 17, 2014 --
   . Added capability to track particles outside of the plume during a 
     bent_plume_model simulation using the single_bubble_model
   . Fixed a bug where a particle outside the plume would continue to dissolve
     and add dissolved mass to the plume.
v0.1.6, November 7, 2014 --
   . Added new module bent_plume_model to simulate a single- or multiphase 
     plume in a crossflow.  The single-phase version is based on Lee and 
     Cheung (1990).  The multiphase version updates that model with the 
     multiphase dynamics as implemented in the stratified_plume_model.  The
     dispersed phase is tracked using an analytical function; particles leave
     the plume when they move outside the plume half-width.
   . Added new module dispersed_phases to handle all Particle objects within
     the TAMOC modeling suite.  This moves the single_bubble_model.Particle
     and stratified_plume_model.Particle object into the new module.  Also, 
     moved particle-related helper functions (e.g., particle_from_Q) to the
     new module.  This centralizes all particle dynamics to a single module.
     The new version of the model is fully backward compatible with the 
     original ./bin example files.  Because the unit tests directly access
     module objects and methods that the user would not normally address, 
     the ./test files have been updated slightly to point at the new locations
     of the dispersed_phases objects and functions.
   . Consolidated the save/load functions for particles into the 
     dispersed_phases module.  The save and load methods for the 
     single_bubble_model were poorly done.  These have been upgraded to match
     the methods used in the stratified_plume_model.  As a result, the new
     load_sim function is not compatible with output from the 
     single_bubble_model from previous versions of the TAMOC suite.
   . Added three-dimensional position to the single_bubble_model and the 
     capability for the bubble to be transported by a three-dimensional
     ambient current.  These changes are fully backward-compatible with the
     ./bin examples.  The dimensions of the state space changed, and the 
     appropriate changes had to be included in the ./test unit tests that 
     check individual members of the state space.
   . Renamed the numerical solutions to the stratified_plume_model and the 
     bent_plume_model from simp.py to smp.py and from limp.py to lmp.py.
   . Added a new module model_share.py that contains functionality shared by
     all models and not already available in an appropriate location.  For 
     this release, the model_share module writes the header to the netCDF 
     output files and loads an ambient.Profile object based on information
     read from the netCDF output file.
   . Updated the documentation for the new model structure and included 
     documentation of the full modeling suite.
v0.1.5, March 12, 2014 --
   . Changed the bubble force in the inner plume object for the stratified 
     plume model with bubbles dissolve.  The original code has a weak bubble 
     force with the bubble density is set to the plume density and the bubble
     buoyancy is with respect to the ambient density.  A new if-statement
     replaces "if self.fb[i] == 0." with if the current particle density is
     equal to the local water density, then self.fb and self.xi are both 
     zero.  This is inserted on line 1199.  All test cases still pass.
   . Changed sintef.rosin_rammler() function so that when the size 
     distribution becomes larger than the maximum stable particle size no
     mass is lost by the distribution truncation.  Added else statement on 
     line 334.
v0.1.4, March 12, 2014 --
   . Created the new test cases test_sintef and test_params.
   . Added examples for using the sintef and params modules to the ./bin 
     directories.
   . Updated the documentation with the complete distribution.
   . Modified the simp.outer_cpic() so that if the predicted flux in the outer
     plume is actually upward, the outer plume is not considered to be viable.
     Also, verified that the outer plume is not valid if the volume flux is
     NaN.  Added "or" statements on line 963::
        if dQdz > 0 or Q > 0 or np.isnan(Q):
   . Added a new stop criteria for the simp.calculate() function so that if
     the progress stops, the current integration ends: 
        if z[-1] == z[-2]:
           stop = True
     added to lines 354-355.
   . Modified the way the independent variable is stored in the calculate()
     function of the single_bubble_model.py and simp.py to make it compatible
     with the most recent version of numpy in the Enthough Canopy 
     distribution.
   . Changed the number of required significant figures in the tests for 
     the top of the solution vector in test.spm.py (made it less strict of a
     test). Because of the adaptive step-size solver and the very large 
     integration distances, small changes in the way updated numerical 
     packages work can result in differences in the solution in the third 
     and fourth significant figure.  Rather than update the test solution 
     to match updated numpy/Python packages, the original test solution is
     retained with the two significant figure threshold for passing.
v0.1.3, February 25, 2014 -- 
   . Updated the test cases for test_ambient, test_dbm_object, test_dbm,
     test_sbm, and test_spm to reflect the other changes in this update.
   . Replaced delDiss (the dissolution of species j summed over all particles) 
     on line 144 with a new variable delDiss_p (the dissolution of species j 
     summed over a single particle) in the heat transfer equation for each 
     individual particle.  The old version double-counts heat loss from the  
     particle as a result of dissolution when more than one particle in the 
     solution is dissolving.
   . Changed simp.py line 130ff so that yp[idx] is used (the dissolution of
     species j for particle i) instead of delDiss[j] (the dissolution of
     species j summed over all particles).  The old version double-counts
     heat of solution when more than one particle in the solution is 
     dissolving.
   . Added temperature as an output from the sbm.particle.update method so 
     that temperature is consistently handled throughout the simulation.
   . Updated the ambient.extend_profile_deeper method so that the correct
     pressure is computed for the extended region of the profile.
   . Fixed a bug in the Fortran files so that the Peng-Robinson equation of 
     state module can always find the correct, non-negative minimum and 
     maximum roots.  Previously, the minimum root was assumed to be less than
     1.0, which caused spurious behavior at extreme conditions.
   . Fixed a bug in simp.py to make sure the temperature is always modeled 
     correctly.
   . Added the Rosin-Rammler distribution to the SINTEF module.
   . Added hydrate dissolution reduction factor as a function of hydrate 
     stability for the mass transfer method of the FluidParticle object in 
     dbm.py.
   . Added a hydrate stability zone calculation to the FluidMixture object
     in dbm.py.
   . Updated model save functions so that when variables are defined as None
     their assumed values are saved.
   . Removed stop criteria based on the maximum number of calculation steps 
     in both the single bubble model and stratified plume model so that the 
     models always runs to completion.  This means if an error occurs, they
     may get stuck in a loop trying to get past a numerical obstacle, but the
     alternative is that the model stops for the wrong reasons.  This was
     previously part of the model to aid during development.  
   . Added new module sintef.py to compute the initial bubble and droplet 
     size distribution using the SINTEF model.
v0.1.2, September 19, 2013 --
   . Moved octant import to the functions that require it.  
   . Added `from copy import copy` to `single_bubble_model.py`
   . Added test for insoluble particles to ./test/test_sbm.py
   . Changed tests for ./test/test_spm.py to avoid instability in outer plume 
     initial conditions and to reduce the number of iterations for the full 
     plume simulations.  This was required since different versions of numpy
     and scipy were getter slightly different results after multiple 
     iterations:  not for the overall solution, but very small errors in 
     heights lead to measureable differences in output at identical heights.
     This is a result of the adaptive time step stiff solver and iteration.
v0.1.1, September 11, 2013 -- 
   . Updated the `spm_test.py` file with a complete test suite.
   . Added a plotting method for the complete suite of model variables in the
     Stratified Plume Model.
   . Updated the documentation with a few missing functions.
   . Includes the following bug fixes:
      . Fixed plotting methods in the single bubble model and stratified plume
        model when an inert particle (which has one component) clashed with 
        the modeled dissolved concentrations (which has zero components).
      . Set the temperature of the fluid surrounding a particle in the inner 
        plume equal to the temperature of the inner plume (once heat transfer
        is complete).  Previously, this was set equal to the ambient 
        temperature.
      . Changed the temperature correction in the `simp` module to reflect
        the temperature of the inner plume instead of the ambient temperature
        when heat transfer is complete.
v0.1.0, August 20, 2013 -- 
   Initial release including the stratified plume model.  Also includes:
      . Fixed pressure correction for Henry's coefficients to be based on 
        the total pressure at depth instead of the partial pressure of each
        species.
      . Changed the `ambient.Profile` object so that it removes any 
        unstable parts of the density profile.  
      . Small changes to the single bubble model so that both the single
        bubble model and the stratified plume model have parallel 
        programming architecture and behavior.  
v0.0.3, July 31, 2013 -- 
   Initial release including the ambient module and single bubble model
v0.0.2, July 8, 2013 -- 
   Initial release including the discrete bubble model
v0.0.1, July 1, 2013 -- 
   Development beta testing