research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Cleaned up Doxygen docs for class MultiPhaseEquil

Browse source
This commit is contained in:
Ray Speth 2013-04-18 22:07:49 +00:00
parent 651ce785cc
commit 723cc0a709
2 changed files with 72 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

87
include/cantera/equil/MultiPhaseEquil.h
View file

@ -7,32 +7,32 @@
namespace Cantera namespace Cantera
{ {
/** /*!
* Multiphase chemical equilibrium solver. Class MultiPhaseEquil * Multiphase chemical equilibrium solver. Class MultiPhaseEquil is designed
* is designed to be used to set a mixture containing one or more * to be used to set a mixture containing one or more phases to a state of
* phases to a state of chemical equilibrium. It implements the * chemical equilibrium. It implements the VCS algorithm, described in Smith
* VCS algorithm, described in Smith and Missen, "Chemical * and Missen, "Chemical Reaction Equilibrium."
* Reaction Equilibrium."
* *
* This class only handles chemical equilibrium at a specified * This class only handles chemical equilibrium at a specified temperature and
* temperature and pressure. To compute equilibrium holding other * pressure. To compute equilibrium holding other properties fixed, it is
* properties fixed, it is necessary to iterate on T and P in an * necessary to iterate on T and P in an "outer" loop, until the specified
* "outer" loop, until the specified properties have the desired * properties have the desired values. This is done, for example, in method
* values. This is done, for example, in method equilibrate of * equilibrate of class MultiPhase.
* class MultiPhase.
* *
* This class is primarily meant to be used internally by the * This class is primarily meant to be used internally by the equilibrate
* equilibrate method of class MultiPhase, although there is no * method of class MultiPhase, although there is no reason it cannot be used
* reason it cannot be used directly in application programs if * directly in application programs if desired.
* desired.
* *
* @ingroup equil * @ingroup equil
*/ */
class MultiPhaseEquil class MultiPhaseEquil
{ {
public: public:
//! Construct a multiphase equilibrium manager for a multiphase mixture.
//! @param mix Pointer to a multiphase mixture object.
//! @param start If true, the initial composition will be determined by a
//! linear Gibbs minimization, otherwise the initial mixture
//! composition will be used.
MultiPhaseEquil(MultiPhase* mix, bool start=true, int loglevel = 0); MultiPhaseEquil(MultiPhase* mix, bool start=true, int loglevel = 0);
virtual ~MultiPhaseEquil() {} virtual ~MultiPhaseEquil() {}
@ -65,6 +65,7 @@ public:
doublereal error(); doublereal error();
#if defined(WITH_HTML_LOGS) #if defined(WITH_HTML_LOGS)
//! Return a string specifying the jth reaction.
std::string reactionString(size_t j); std::string reactionString(size_t j);
void printInfo(int loglevel); void printInfo(int loglevel);
#else #else
@ -88,16 +89,56 @@ public:
double phaseMoles(size_t iph) const; double phaseMoles(size_t iph) const;
protected: protected:
//! This method finds a set of component species and a complete set of
//! formation reactions for the non-components in terms of the components.
//! In most cases, many different component sets are possible, and
//! therefore neither the components returned by this method nor the
//! formation reactions are unique. The algorithm used here is described
//! in Smith and Missen, Chemical Reaction Equilibrium Analysis.
//!
//! The component species are taken to be the first M species in array
//! 'species' that have linearly-independent compositions.
//!
//! @param order On entry, vector \a order should contain species index
//! numbers in the order of decreasing desirability as a component.
//! For example, if it is desired to choose the components from among
//! the major species, this array might list species index numbers in
//! decreasing order of mole fraction. If array 'species' does not
//! have length = nSpecies(), then the species will be considered as
//! candidates to be components in declaration order, beginning with
//! the first phase added.
void getComponents(const std::vector<size_t>& order); void getComponents(const std::vector<size_t>& order);
//! Estimate the initial mole numbers. This is done by running each
//! reaction as far forward or backward as possible, subject to the
//! constraint that all mole numbers remain non-negative. Reactions for
//! which \f$ \Delta \mu^0 \f$ are positive are run in reverse, and ones
//! for which it is negative are run in the forward direction. The end
//! result is equivalent to solving the linear programming problem of
//! minimizing the linear Gibbs function subject to the element and non-
//! negativity constraints.
int setInitialMoles(int loglevel = 0); int setInitialMoles(int loglevel = 0);
void computeN(); void computeN();
//! Take one step in composition, given the gradient of G at the starting
//! point, and a vector of reaction steps dxi.
doublereal stepComposition(int loglevel = 0); doublereal stepComposition(int loglevel = 0);
//void sort(vector_fp& x);
//! Re-arrange a vector of species properties in sorted form
//! (components first) into unsorted, sequential form.
void unsort(vector_fp& x); void unsort(vector_fp& x);
void step(doublereal omega, vector_fp& deltaN, int loglevel = 0); void step(doublereal omega, vector_fp& deltaN, int loglevel = 0);
//! Compute the change in extent of reaction for each reaction.
doublereal computeReactionSteps(vector_fp& dxi); doublereal computeReactionSteps(vector_fp& dxi);
void updateMixMoles(); void updateMixMoles();
//! Clean up the composition. The solution algorithm can leave some
//! species in stoichiometric condensed phases with very small negative
//! mole numbers. This method simply sets these to zero.
void finish(); void finish();
// moles of the species with sorted index ns // moles of the species with sorted index ns
@ -143,9 +184,8 @@ protected:
vector_int m_dsoln; vector_int m_dsoln;
vector_int m_incl_element, m_incl_species; vector_int m_incl_element, m_incl_species;
// Vector of indices for species that are included in the // Vector of indices for species that are included in the calculation.
// calculation. This is used to exclude pure-phase species // This is used to exclude pure-phase species with invalid thermo data
// with invalid thermo data
std::vector<size_t> m_species; std::vector<size_t> m_species;
std::vector<size_t> m_element; std::vector<size_t> m_element;
std::vector<bool> m_solnrxn; std::vector<bool> m_solnrxn;
@ -154,5 +194,4 @@ protected:
} }
#endif #endif

77
src/equil/MultiPhaseEquil.cpp
View file

@ -17,15 +17,15 @@ namespace Cantera
{ {
#if defined(WITH_HTML_LOGS) #if defined(WITH_HTML_LOGS)
/// Used to print reaction equations. Given a stoichiometric
/// coefficient 'nu' and a chemical symbol 'sym', return a string //! Used to print reaction equations. Given a stoichiometric coefficient 'nu'
/// for this species in the reaction. //! and a chemical symbol 'sym', return a string for this species in the
/// @param first if this is false, then a " + " string will be //! reaction.
/// added to the beginning of the string. //! @param first if this is false, then a " + " string will be added to the
/// @param nu Stoichiometric coefficient. May be positive or negative. The //! beginning of the string.
/// absolute value will be used in the string. //! @param nu Stoichiometric coefficient. May be positive or negative. The
/// @param sym Species chemical symbol. //! absolute value will be used in the string.
/// //! @param sym Species chemical symbol.
static string coeffString(bool first, doublereal nu, string sym) static string coeffString(bool first, doublereal nu, string sym)
{ {
if (nu == 0.0) { if (nu == 0.0) {
@ -43,12 +43,6 @@ static string coeffString(bool first, doublereal nu, string sym)
} }
#endif #endif
/// Constructor. Construct a multiphase equilibrium manager for a
/// multiphase mixture.
/// @param mix Pointer to a multiphase mixture object.
/// @param start If true, the initial composition will be
/// determined by a linear Gibbs minimization, otherwise the
/// initial mixture composition will be used.
MultiPhaseEquil::MultiPhaseEquil(MultiPhase* mix, bool start, int loglevel) : m_mix(mix) MultiPhaseEquil::MultiPhaseEquil(MultiPhase* mix, bool start, int loglevel) : m_mix(mix)
{ {
// the multi-phase mixture // the multi-phase mixture
@ -209,7 +203,6 @@ MultiPhaseEquil::MultiPhaseEquil(MultiPhase* mix, bool start, int loglevel) : m_
// numbers for the included species. // numbers for the included species.
} }
doublereal MultiPhaseEquil::equilibrate(int XY, doublereal err, doublereal MultiPhaseEquil::equilibrate(int XY, doublereal err,
int maxsteps, int loglevel) int maxsteps, int loglevel)
{ {
@ -264,10 +257,6 @@ void MultiPhaseEquil::updateMixMoles()
m_mix->setMoles(DATA_PTR(m_work3)); m_mix->setMoles(DATA_PTR(m_work3));
} }
/// Clean up the composition. The solution algorithm can leave
/// some species in stoichiometric condensed phases with very
/// small negative mole numbers. This method simply sets these to
/// zero.
void MultiPhaseEquil::finish() void MultiPhaseEquil::finish()
{ {
fill(m_work3.begin(), m_work3.end(), 0.0); fill(m_work3.begin(), m_work3.end(), 0.0);
@ -278,16 +267,6 @@ void MultiPhaseEquil::finish()
m_mix->setMoles(DATA_PTR(m_work3)); m_mix->setMoles(DATA_PTR(m_work3));
} }
/// Estimate the initial mole numbers. This is done by running
/// each reaction as far forward or backward as possible, subject
/// to the constraint that all mole numbers remain
/// non-negative. Reactions for which \f$ \Delta \mu^0 \f$ are
/// positive are run in reverse, and ones for which it is negative
/// are run in the forward direction. The end result is equivalent
/// to solving the linear programming problem of minimizing the
/// linear Gibbs function subject to the element and
/// non-negativity constraints.
int MultiPhaseEquil::setInitialMoles(int loglevel) int MultiPhaseEquil::setInitialMoles(int loglevel)
{ {
size_t ik, j; size_t ik, j;
@ -372,28 +351,6 @@ int MultiPhaseEquil::setInitialMoles(int loglevel)
return 0; return 0;
} }
/// This method finds a set of component species and a complete
/// set of formation reactions for the non-components in terms of
/// the components. Note that in most cases, many different
/// component sets are possible, and therefore neither the
/// components returned by this method nor the formation
/// reactions are unique. The algorithm used here is described in
/// Smith and Missen, Chemical Reaction Equilibrium Analysis.
///
/// The component species are taken to be the first M species
/// in array 'species' that have linearly-independent compositions.
///
/// @param order On entry, vector \a order should contain species
/// index numbers in the order of decreasing desirability as a
/// component. For example, if it is desired to choose the
/// components from among the major species, this array might
/// list species index numbers in decreasing order of mole
/// fraction. If array 'species' does not have length =
/// nSpecies(), then the species will be considered as candidates
/// to be components in declaration order, beginning with the
/// first phase added.
///
void MultiPhaseEquil::getComponents(const std::vector<size_t>& order) void MultiPhaseEquil::getComponents(const std::vector<size_t>& order)
{ {
size_t m, k, j; size_t m, k, j;
@ -545,11 +502,6 @@ void MultiPhaseEquil::getComponents(const std::vector<size_t>& order)
} }
} }
/// Re-arrange a vector of species properties in sorted form
/// (components first) into unsorted, sequential form.
void MultiPhaseEquil::unsort(vector_fp& x) void MultiPhaseEquil::unsort(vector_fp& x)
{ {
copy(x.begin(), x.end(), m_work2.begin()); copy(x.begin(), x.end(), m_work2.begin());
@ -601,7 +553,6 @@ void MultiPhaseEquil::printInfo(int loglevel)
} }
} }
/// Return a string specifying the jth reaction.
string MultiPhaseEquil::reactionString(size_t j) string MultiPhaseEquil::reactionString(size_t j)
{ {
string sr = "", sp = ""; string sr = "", sp = "";
@ -664,9 +615,6 @@ void MultiPhaseEquil::step(doublereal omega, vector_fp& deltaN,
} }
} }
/// Take one step in composition, given the gradient of G at the
/// starting point, and a vector of reaction steps dxi.
doublereal MultiPhaseEquil:: doublereal MultiPhaseEquil::
stepComposition(int loglevel) stepComposition(int loglevel)
{ {
@ -774,12 +722,8 @@ stepComposition(int loglevel)
return omega; return omega;
} }
/// Compute the change in extent of reaction for each reaction.
doublereal MultiPhaseEquil::computeReactionSteps(vector_fp& dxi) doublereal MultiPhaseEquil::computeReactionSteps(vector_fp& dxi)
{ {
size_t j, k, ik, kc, ip; size_t j, k, ik, kc, ip;
doublereal stoich, nmoles, csum, term1, fctr, rfctr; doublereal stoich, nmoles, csum, term1, fctr, rfctr;
vector_fp nu; vector_fp nu;
@ -1098,7 +1042,4 @@ void MultiPhaseEquil::reportCSV(const std::string& reportFile)
fclose(FP); fclose(FP);
} }
} }