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

Cleaned up Doxygen documentation for class VPSSMgr and descendants

Browse source
This commit is contained in:
Ray Speth 2013-03-07 18:51:11 +00:00
parent 4671f857d0
commit b4506cebe1
12 changed files with 295 additions and 1254 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

406
include/cantera/thermo/VPSSMgr.h
View file

@ -29,75 +29,68 @@ class PDSS;
/**
* @defgroup mgrpdssthermocalc Managers for Calculating Standard-State Thermodynamics
*
* To compute the thermodynamic properties of multicomponent
* solutions, it is necessary to know something about the
* thermodynamic properties of the individual species present in
* the solution. Exactly what sort of species properties are
* required depends on the thermodynamic model for the
* solution. For a gaseous solution (i.e., a gas mixture), the
* species properties required are usually ideal gas properties at
* the mixture temperature and at a reference pressure (almost always at
* 1 bar). For other types of solutions, however, it may
* not be possible to isolate the species in a "pure" state. For
* example, the thermodynamic properties of, say, Na+ and Cl- in
* saltwater are not easily determined from data on the properties
* of solid NaCl, or solid Na metal, or chlorine gas. In this
* case, the solvation in water is fundamental to the identity of
* the species, and some other reference state must be used. One
* common convention for liquid solutions is to use thermodynamic
* data for the solutes in the limit of infinite dilution within the
* pure solvent; another convention is to reference all properties
* to unit molality.
* To compute the thermodynamic properties of multicomponent solutions, it is
* necessary to know something about the thermodynamic properties of the
* individual species present in the solution. Exactly what sort of species
* properties are required depends on the thermodynamic model for the
* solution. For a gaseous solution (i.e., a gas mixture), the species
* properties required are usually ideal gas properties at the mixture
* temperature and at a reference pressure (almost always at 1 bar). For other
* types of solutions, however, it may not be possible to isolate the species
* in a "pure" state. For example, the thermodynamic properties of, say, Na+
* and Cl- in saltwater are not easily determined from data on the properties
* of solid NaCl, or solid Na metal, or chlorine gas. In this case, the
* solvation in water is fundamental to the identity of the species, and some
* other reference state must be used. One common convention for liquid
* solutions is to use thermodynamic data for the solutes in the limit of
* infinite dilution within the pure solvent; another convention is to
* reference all properties to unit molality.
*
* In defining these standard states for species in a phase, we make
* the following definition. A reference state is a standard state
* of a species in a phase limited to one particular pressure, the reference
* pressure. The reference state specifies the dependence of all
* thermodynamic functions as a function of the temperature, in
* between a minimum temperature and a maximum temperature. The
* reference state also specifies the molar volume of the species
* as a function of temperature. The molar volume is a thermodynamic
* function.
* A full standard state does the same thing as a reference state,
* but specifies the thermodynamics functions at all pressures.
* In defining these standard states for species in a phase, we make the
* following definition. A reference state is a standard state of a species in
* a phase limited to one particular pressure, the reference pressure. The
* reference state specifies the dependence of all thermodynamic functions as
* a function of the temperature, in between a minimum temperature and a
* maximum temperature. The reference state also specifies the molar volume of
* the species as a function of temperature. The molar volume is a
* thermodynamic function. A full standard state does the same thing as a
* reference state, but specifies the thermodynamics functions at all
* pressures.
*
* Class VPSSMgr is the base class
* for a family of classes that compute properties of all
* species in a phase in their standard states, for a range of temperatures
* and pressures.
* Class VPSSMgr is the base class for a family of classes that compute
* properties of all species in a phase in their standard states, for a range
* of temperatures and pressures.
*
* Phases which use the VPSSMGr class must have their respective
* ThermoPhase objects actually be derivatives of the VPStandardState
* class. These classes assume that there exists a standard state
* for each species in the phase, where the Thermodynamic functions are specified
* as a function of temperature and pressure. Standard state thermo objects for each
* species in the phase are all derived from the PDSS virtual base class.
* Calculators for these
* standard state thermo , which coordinate the calculation for all of the species
* in a phase, are all derived from VPSSMgr.
* In turn, these standard states may employ reference state calculation to
* aid in their calculations. And the VPSSMgr calculators may also employ
* SimpleThermo calculators to help in calculating the properties for all of the
* species in a phase. However, there are some PDSS objects which do not employ
* reference state calculations. An example of this is a real equation of state for
* liquid water used within the calculation of brine thermodynamics.
*
* Typically calls to calculate standard state thermo properties are virtual calls
* at the ThermoPhase level. It is left to the child classes of ThermoPhase to
* specify how these are carried out. Usually, this will involve calling the
* m_spthermo pointer to a SpeciesThermo object to calculate the reference state
* thermodynamic properties. Then, the pressure dependence is added in within the
* child ThermoPhase object to complete the specification of the standard state.
* The VPStandardStateTP class, however, redefines the calls to the calculation of
* standard state properties to use VPSSMgr class calls. A listing of
* these classes and important pointers are supplied below.
* Phases which use the VPSSMGr class must have their respective ThermoPhase
* objects actually be derivatives of the VPStandardState class. These classes
* assume that there exists a standard state for each species in the phase,
* where the Thermodynamic functions are specified as a function of
* temperature and pressure. Standard state thermo objects for each species
* in the phase are all derived from the PDSS virtual base class. Calculators
* for these standard state thermo , which coordinate the calculation for all
* of the species in a phase, are all derived from VPSSMgr. In turn, these
* standard states may employ reference state calculation to aid in their
* calculations. And the VPSSMgr calculators may also employ SimpleThermo
* calculators to help in calculating the properties for all of the species in
* a phase. However, there are some PDSS objects which do not employ reference
* state calculations. An example of this is a real equation of state for
* liquid water used within the calculation of brine thermodynamics.
*
* Typically calls to calculate standard state thermo properties are virtual
* calls at the ThermoPhase level. It is left to the child classes of
* ThermoPhase to specify how these are carried out. Usually, this will
* involve calling the m_spthermo pointer to a SpeciesThermo object to
* calculate the reference state thermodynamic properties. Then, the pressure
* dependence is added in within the child ThermoPhase object to complete the
* specification of the standard state. The VPStandardStateTP class, however,
* redefines the calls to the calculation of standard state properties to use
* VPSSMgr class calls. A listing of these classes and important pointers are
* supplied below.
*
* - ThermoPhase
* - \link Cantera::ThermoPhase::m_spthermo m_spthermo\endlink
* This is a pointer to a %SpeciesThermo manager class that
* handles the reference %state Thermodynamic calculations.
* .
* - VPStandardStateTP (inherits from %ThermoPhase)
* - \link Cantera::ThermoPhase::m_spthermo m_spthermo\endlink
* %SpeciesThermo manager handling reference %state Thermodynamic calculations.
@ -110,31 +103,24 @@ class PDSS;
* This is a pointer to a %VPSSMgr class which handles the
* standard %state thermo calculations. It may
* or may not use the pointer, m_spthermo, in its calculations.
* .
* .
*
* The following classes inherit from VPSSMgr. Each of these classes
* handle multiple species and by definition all of the species in a phase.
* It is a requirement that a VPSSMgr object handles all of the
* species in a phase.
*
*
* - VPSSMgr_IdealGas
* - standardState model = "IdealGas"
* - This model assumes that all species in the phase obey the
* ideal gas law for their pressure dependence. The manager
* uses a SpeciesThermo object to handle the calculation of the
* reference state.
* .
*
* - VPSSMgr_ConstVol
* - standardState model = "ConstVol"
* - This model assumes that all species in the phase obey the
* constant partial molar volume pressure dependence.
* The manager uses a SpeciesThermo object to handle the
* calculation of the reference state.
* .
*
* - VPSSMgr_Water_ConstVol
* - standardState model = "Water_ConstVol"
* - This model assumes that all species but one in the phase obey the
@ -143,22 +129,16 @@ class PDSS;
* calculation of the reference state for those species.
* Species 0 is assumed to be water, and a real equation
* of state is used to model the T, P behavior.
* .
*
* - VPSSMgr_Water_HKFT
* - standardState model = "Water_HKFT"
* - This model assumes that all species but one in the phase obey the
* HKFT equation of state.
* Species 0 is assumed to be water, and a real equation
* of state is used to model the T, P behavior.
* .
*
* - VPSSMgr_General
* - standardState model = "General"
* - This model is completely general. Nothing is assumed at this
* level. Calls consist of loops to PDSS property evaluations.
* .
* .
*
* The choice of which VPSSMgr object to be used is implicitly made by
* %Cantera by querying the XML data file for compatibility.
@ -168,15 +148,15 @@ class PDSS;
* explicitly requests that the VPSSMgr_IdealGas
* object be used to handle the standard state thermodynamics calculations.
*
* @verbatim
<phase id="Silane_Pyrolysis" dim="3">
. . .
<thermo model="VPIdealGas">
<standardState model="IdealGas"\>
<\thermo>
. . .
<\phase>
@endverbatim
* @code
* <phase id="Silane_Pyrolysis" dim="3">
* . . .
* <thermo model="VPIdealGas">
* <standardState model="IdealGas"\>
* <\thermo>
* . . .
* <\phase>
* @endcode
*
* If it turns out that the VPSSMgr_IdealGas class can not handle the standard
* state calculation, then %Cantera will fail during the instantiation phase
@ -184,28 +164,26 @@ class PDSS;
*
* In the source code listing above, the thermo model, VPIdealGas ,was requested. The
* thermo model specifies the type of ThermoPhase object to use. In this case
* the object IdealSolnGasVPSS (with the ideal gas suboption) is used. %IdealSolnGasVPSS
* the object IdealSolnGasVPSS (with the ideal gas suboption) is used. IdealSolnGasVPSS
* inherits from VPStandardStateTP, so that it actually has a VPSSMgr pointer
* to be specified. Note, in addition to the IdealGas entry to the model
* parameter in standardState node, we could have also specified the "General"
* option. The general option will always work. An example of this
* usage is listed below.
*
* @verbatim
<phase id="Silane_Pyrolysis" dim="3">
. . .
<thermo model="VPIdealGas">
<standardState model="General"\>
<\thermo>
. . .
<\phase>
@endverbatim
*
* The "General" option will cause the VPSSMgr_General %VPSSMgr class to be used.
* In this manager, the calculations are all handled at the PDSS object
* level. This is completely general, but, may be significantly
* slower.
* @code
* <phase id="Silane_Pyrolysis" dim="3">
* . . .
* <thermo model="VPIdealGas">
* <standardState model="General"\>
* <\thermo>
* . . .
* <\phase>
* @endcode
*
* The "General" option will cause the VPSSMgr_General %VPSSMgr class to be
* used. In this manager, the calculations are all handled at the PDSS object
* level. This is completely general, but, may be significantly slower.
*
* @ingroup thermoprops
*/
@ -215,12 +193,9 @@ class PDSS;
/*!
* This class defines the interface which all subclasses must implement.
*
* Class %VPSSMgr is the base class
* for a family of classes that compute properties of a set of
* species in their standard state at a range of temperatures
* and pressures.
*
* and pressure are unchanged.
* Class VPSSMgr is the base class for a family of classes that compute
* properties of a set of species in their standard state at a range of
* temperatures and pressures.
*
* If #m_useTmpRefStateStorage is set to true, then the following internal
* arrays, containing information about the reference arrays,
@ -261,14 +236,11 @@ class PDSS;
*/
class VPSSMgr
{
public:
//! Constructor
/*!
* @param vptp_ptr Pointer to the Variable pressure %ThermoPhase object
* This object must have already been malloced.
*
* @param spth Pointer to the optional SpeciesThermo object
* that will handle the calculation of the reference
* state thermodynamic coefficients.
@ -278,37 +250,21 @@ public:
//! Destructor
virtual ~VPSSMgr();
//! Copy Constructor for the %SpeciesThermo object.
/*!
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Copy Constructor
VPSSMgr(const VPSSMgr& right);
//! Assignment operator for the %SpeciesThermo object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr& operator=(const VPSSMgr& right);
//! Duplication routine for objects which inherit from
//! %VPSSMgr
//! Duplication routine for objects which derive from VPSSMgr
/*!
* This virtual routine can be used to duplicate %VPSSMgr objects
* inherited from %VPSSMgr even if the application only has
* a pointer to %VPSSMgr to work with.
* This function can be used to duplicate objects derived from VPSSMgr
* even if the application only has a pointer to VPSSMgr to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
/*!
* @name Properties of the Standard State of the Species in the Solution
*
*/
//@{
//! @name Properties of the Standard State of the Species in the Solution
//! @{
//!Get the array of chemical potentials at unit activity.
/*!
@ -321,9 +277,8 @@ public:
virtual void getStandardChemPotentials(doublereal* mu) const;
/**
* Get the nondimensional Gibbs functions for the species
* at their standard states of solution at the current T and P
* of the solution.
* Get the nondimensional Gibbs functions for the species at their
* standard states of solution at the current T and P of the solution.
*
* @param grt Output vector of nondimensional standard state
* Gibbs free energies. length = m_kk.
@ -331,9 +286,8 @@ public:
virtual void getGibbs_RT(doublereal* grt) const;
/**
* Get the nondimensional Enthalpy functions for the species
* at their standard states at the current
* <I>T</I> and <I>P</I> of the solution.
* Get the nondimensional Enthalpy functions for the species at their
* standard states at the current *T* and *P* of the solution.
*
* @param hrt Output vector of standard state enthalpies.
* length = m_kk. units are unitless.
@ -347,24 +301,22 @@ public:
}
/**
* Get the array of nondimensional Enthalpy functions for the
* standard state species
* at the current <I>T</I> and <I>P</I> of the solution.
* Get the array of nondimensional Enthalpy functions for the standard
* state species at the current *T* and *P* of the solution.
*
* @param sr Output vector of nondimensional standard state
* entropies. length = m_kk.
*/
virtual void getEntropy_R(doublereal* sr) const;
//! Return a reference to a vector of the entropies of the
//! species
//! Return a reference to a vector of the entropies of the species
const vector_fp& entropy_R() const {
return m_sss_R;
}
//! Returns the vector of nondimensional
//! internal Energies of the standard state at the current temperature
//! and pressure of the solution for each species.
//! Returns the vector of nondimensional internal Energies of the standard
//! state at the current temperature and pressure of the solution for each
//! species.
/*!
* The internal energy is calculated from the enthalpy from the
* following formula:
@ -378,18 +330,15 @@ public:
*/
virtual void getIntEnergy_RT(doublereal* urt) const;
//! Get the nondimensional Heat Capacities at constant
//! pressure for the standard state of the species
//! at the current T and P.
//! Get the nondimensional Heat Capacities at constant pressure for the
//! standard state of the species at the current T and P.
/*!
*
* This is redefined here to call the internal function, _updateStandardStateThermo(),
* which calculates all standard state properties at the same time.
*
* @param cpr Output vector containing the
* the nondimensional Heat Capacities at constant
* pressure for the standard state of the species.
* Length: m_kk.
* @param cpr Output vector containing the the nondimensional Heat
* Capacities at constant pressure for the standard state of
* the species. Length: m_kk.
*/
virtual void getCp_R(doublereal* cpr) const;
@ -399,15 +348,14 @@ public:
return m_cpss_R;
}
//! Get the molar volumes of each species in their standard
//! states at the current
//! <I>T</I> and <I>P</I> of the solution.
//! Get the molar volumes of each species in their standard states at the
//! current *T* and *P* of the solution.
/*!
* units = m^3 / kmol
*
* This is redefined here to call the internal function,
* _updateStandardStateThermo(),
* which calculates all standard state properties at the same time.
* _updateStandardStateThermo(), which calculates all standard state
* properties at the same time.
*
* @param vol Output vector of species volumes. length = m_kk.
* units = m^3 / kmol
@ -421,23 +369,20 @@ public:
}
public:
//@}
/// @name Thermodynamic Values for the Species Reference States (VPStandardStateTP)
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions
* are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
/*! @name Thermodynamic Values for the Species Reference States
* There are also temporary variables for holding the species reference-
* state values of Cp, H, S, and V at the last temperature and reference
* pressure called. These functions are not recalculated if a new call is
* made using the previous temperature. All calculations are done within
* the routine _updateRefStateThermo().
*/
//@{
/*!
* Returns the vector of nondimensional
* enthalpies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* Returns the vector of nondimensional enthalpies of the reference state
* at the current temperature of the solution and the reference pressure
* for the species.
*
* @param hrt Output vector contains the nondimensional enthalpies
* of the reference state of the species
@ -446,9 +391,9 @@ public:
virtual void getEnthalpy_RT_ref(doublereal* hrt) const;
/*!
* Returns the vector of nondimensional
* Gibbs free energies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* Returns the vector of nondimensional Gibbs free energies of the
* reference state at the current temperature of the solution and the
* reference pressure for the species.
*
* @param grt Output vector contains the nondimensional Gibbs free energies
* of the reference state of the species
@ -463,10 +408,9 @@ public:
}
/*!
* Returns the vector of the
* gibbs function of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* units = J/kmol
* Returns the vector of the gibbs function of the reference state at the
* current temperature of the solution and the reference pressure for the
* species. units = J/kmol
*
* @param g Output vector contain the Gibbs free energies
* of the reference state of the species
@ -475,9 +419,9 @@ public:
virtual void getGibbs_ref(doublereal* g) const ;
/*!
* Returns the vector of nondimensional
* entropies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* Returns the vector of nondimensional entropies of the reference state
* at the current temperature of the solution and the reference pressure
* for the species.
*
* @param er Output vector contain the nondimensional entropies
* of the species in their reference states
@ -486,10 +430,9 @@ public:
virtual void getEntropy_R_ref(doublereal* er) const ;
/*!
* Returns the vector of nondimensional
* constant pressure heat capacities of the reference state
* at the current temperature of the solution
* and reference pressure for the species.
* Returns the vector of nondimensional constant pressure heat capacities
* of the reference state at the current temperature of the solution and
* reference pressure for the species.
*
* @param cpr Output vector contains the nondimensional heat capacities
* of the species in their reference states
@ -498,7 +441,7 @@ public:
virtual void getCp_R_ref(doublereal* cpr) const ;
//! Get the molar volumes of the species reference states at the current
//! <I>T</I> and <I>P_ref</I> of the solution.
//! *T* and *P_ref* of the solution.
/*!
* units = m^3 / kmol
*
@ -508,8 +451,7 @@ public:
virtual void getStandardVolumes_ref(doublereal* vol) const ;
//@}
/// @name Setting the Internal State of the System
/*!
/*! @name Setting the Internal State of the System
* All calls to change the internal state of the system's T and P
* are done through these routines
* - setState_TP()
@ -569,7 +511,7 @@ public:
//! Updates the internal standard state thermodynamic vectors at the
//! current T and P of the solution.
/*!
* If you are to peak internally inside the object, you need to
* If you are to peek internally inside the object, you need to
* call these functions after setState functions in order to be sure
* that the vectors are current.
*/
@ -578,7 +520,7 @@ public:
//! Updates the internal reference state thermodynamic vectors at the
//! current T of the solution and the reference pressure.
/*!
* If you are to peak internally inside the object, you need to
* If you are to peek internally inside the object, you need to
* call these functions after setState functions in order to be sure
* that the vectors are current.
*/
@ -591,11 +533,10 @@ protected:
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called for every call to functions in this
* class. It checks to see whether the temperature or pressure has changed and
* thus the ss thermodynamics functions for all of the species
* must be recalculated.
* If m_useTmpStandardStateStorage is true, this function must be called
* for every call to functions in this class. It checks to see whether the
* temperature or pressure has changed and thus the ss thermodynamics
* functions for all of the species must be recalculated.
*
* This function is responsible for updating the following internal members,
* when m_useTmpStandardStateStorage is true.
@ -609,7 +550,8 @@ protected:
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called by child classes to update internal member data.
*
* Note, this will throw an error. It must be reimplemented in derived classes.
* Note, the base class implementation will throw an error. It must be
* reimplemented in derived classes.
*
* Underscore updates never check for the state of the system
* They just do the calculation.
@ -636,12 +578,10 @@ public:
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of ss properties
/*!
@ -652,11 +592,10 @@ public:
//! Minimum temperature.
/*!
* If no argument is supplied, this
* method returns the minimum temperature for which \e all
* parameterizations are valid. If an integer index k is
* supplied, then the value returned is the minimum
* temperature for species k in the phase.
* If no argument is supplied, this method returns the minimum temperature
* for which \e all parameterizations are valid. If an integer index k is
* supplied, then the value returned is the minimum temperature for
* species k in the phase.
*
* @param k Species index
*/
@ -664,11 +603,10 @@ public:
//! Maximum temperature.
/*!
* If no argument is supplied, this
* method returns the maximum temperature for which \e all
* parameterizations are valid. If an integer index k is
* supplied, then the value returned is the maximum
* temperature for parameterization k.
* If no argument is supplied, this method returns the maximum temperature
* for which \e all parameterizations are valid. If an integer index k is
* supplied, then the value returned is the maximum temperature for
* parameterization k.
*
* @param k Species Index
*/
@ -676,43 +614,35 @@ public:
//! The reference-state pressure for the standard state
/*!
*
* returns the reference state pressure in Pascals for
* species k. If k is left out of the argument list,
* it returns the reference state pressure for the first
* species.
* Note that some SpeciesThermo implementations, such
* as those for ideal gases, require that all species
* in the same phase have the same reference state pressures.
* Returns the reference state pressure in Pascals for species k. If k is
* left out of the argument list, it returns the reference state pressure
* for the first species. Note that some SpeciesThermo implementations,
* such as those for ideal gases, require that all species in the same
* phase have the same reference state pressures.
*
* @param k Species index. Default is -1, which returns
* the generic answer.
*/
virtual doublereal refPressure(size_t k=npos) const ;
//@}
//! @name Initialization Methods - For Internal use (VPStandardState)
/*!
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally used in application programs.
* To see how they are used, see files importCTML.cpp and
* ThermoFactory.cpp.
/*! @name Initialization Methods - For Internal use
* The following methods are used in the process of constructing the phase
* and setting its parameters from a specification in an input file. They
* are not normally used in application programs. To see how they are
* used, see files importCTML.cpp and ThermoFactory.cpp.
*/
//@{
//! @internal Initialize the object
/*!
* This method is provided to allow
* subclasses to perform any initialization required after all
* species have been added. For example, it might be used to
* resize internal work arrays that must have an entry for
* each species. The base class implementation does nothing,
* and subclasses that do not require initialization do not
* need to overload this method. When importing a CTML phase
* description, this method is called just prior to returning
* from function importPhase().
* This method is provided to allow subclasses to perform any
* initialization required after all species have been added. For example,
* it might be used to resize internal work arrays that must have an entry
* for each species. The base class implementation does nothing, and
* subclasses that do not require initialization do not need to overload
* this method. When importing a CTML phase description, this method is
* called just prior to returning from function importPhase().
*
* @see importCTML.cpp
*/
@ -726,11 +656,10 @@ public:
//! Finalize the thermo after all species have been entered
/*!
* This function is the LAST initialization routine to be
* called. It's called after createInstallPDSS() has been
* called for each species in the phase, and after initThermo()
* has been called.
* It's called via an inner-to-outer onion shell like manner.
* This function is the LAST initialization routine to be called. It's
* called after createInstallPDSS() has been called for each species in
* the phase, and after initThermo() has been called. It's called via an
* inner-to-outer onion shell like manner.
*
* In this routine, we currently calculate the reference pressure,
* the minimum and maximum temperature for the applicability
@ -768,7 +697,6 @@ public:
virtual PDSS* createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr);
//! Initialize the internal shallow pointers in this object
/*!
* There are a bunch of internal shallow pointers that point to the owning
@ -781,7 +709,6 @@ public:
virtual void initAllPtrs(VPStandardStateTP* vp_ptr, SpeciesThermo* sp_ptr);
protected:
//! Number of species in the phase
size_t m_kk;
@ -883,7 +810,6 @@ protected:
*/
mutable vector_fp m_Vss;
//! species reference enthalpies - used by individual PDSS objects
/*!
* Vector containing the species reference enthalpies at T = m_tlast
@ -912,7 +838,6 @@ protected:
*/
mutable vector_fp mPDSS_s0_R;
//! species reference state molar Volumes - used by individual PDSS objects
/**
* Vector containing the rf molar volumes
@ -955,16 +880,13 @@ protected:
*/
mutable vector_fp mPDSS_Vss;
friend class PDSS;
private:
//! Error message to indicate an unimplemented feature
/*!
* @param msg Error message string
*/
void err(const std::string& msg) const;
};
//@}
}

127
include/cantera/thermo/VPSSMgr_ConstVol.h
View file

@ -51,105 +51,44 @@ public:
virtual ~VPSSMgr_ConstVol();
//! Copy Constructor
/*!
* @param right Reference to %VPSSMgr_ConstVol object to be copied into the
* current one.
*/
VPSSMgr_ConstVol(const VPSSMgr_ConstVol& right);
//! Assignment operator for the %VPSSMgr_ConstVol object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %VPSSMgr_ConstVol object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr_ConstVol& operator=(const VPSSMgr_ConstVol& right);
//! Duplicator routine for the VPSSMgr base class
/*!
* This virtual routine can be used to duplicate %VPSSMgr objects
* inherited from %VPSSMgr even if the application only has
* a pointer to %VPSSMgr to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
/*!
* @name Properties of the Standard State of the Species in the Solution
*
* Within VPStandardStateTP, these properties are calculated via a common routine,
* _updateStandardStateThermo(),
* which must be overloaded in inherited objects.
* The values are cached within this object, and are not recalculated unless
* the temperature or pressure changes.
* Within VPStandardStateTP, these properties are calculated via a common
* routine, _updateStandardStateThermo(), which must be overloaded in
* inherited objects. The values are cached within this object, and are
* not recalculated unless the temperature or pressure changes.
*/
//@{
protected:
//! Updates the standard state thermodynamic functions at the current
//! T and P of the solution.
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called whenever the temperature or pressure
* has changed.
*
* This function is responsible for updating the following internal members,
* when m_useTmpStandardStateStorage is true.
*
* - m_hss_RT;
* - m_cpss_R;
* - m_gss_RT;
* - m_sss_R;
* - m_Vss
*
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called every time information is requested from
* this object.
*/
virtual void _updateStandardStateThermo();
//@}
/// @name Thermodynamic Values for the Species Reference States
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
* _updateRefStateThermo() is defined in the parent object.
/*! @name Thermodynamic Values for the Species Reference States
*
* There are also temporary variables for holding the species reference-
* state values of Cp, H, S, and V at the last temperature and reference
* pressure called. These functions are not recalculated if a new call is
* made using the previous temperature. All calculations are done within
* the routine _updateRefStateThermo(). _updateRefStateThermo() is
* defined in the parent object.
*/
//@{
/*!
* Returns the vector of nondimensional
* Gibbs free energies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param grt Output vector contains the nondimensional Gibbs free energies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
virtual void getGibbs_RT_ref(doublereal* grt) const ;
//! Get the molar volumes of the species reference states at the current
//! <I>T</I> and <I>P_ref</I> of the solution.
/*!
* units = m^3 / kmol
*
* @param vol Output vector containing the standard state volumes.
* Length: m_kk.
*/
virtual void getStandardVolumes_ref(doublereal* vol) const ;
//@}
//! @name Initialization Methods - For Internal use
/*!
/*! @name Initialization Methods - For Internal use
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally seen by application programs
@ -157,27 +96,7 @@ protected:
//@{
public:
//! Initialize the VPSSMgr object
/*!
* This method is provided to allow
* subclasses to perform any initialization required after all
* species have been added. For example, it might be used to
* resize internal work arrays that must have an entry for
* each species. It is called after createInstallPDSS() and
* before initThermoXML().
*
* @internal
*/
virtual void initThermo();
//! Initialize the thermo for this standard state thermo calculator
/*!
* This task is done last, after createInstallPDSS() and after
* initThermo().
*
* @param phaseNode Reference to the phase node in the XML tree
* @param id string name of the phase
*/
virtual void initThermoXML(XML_Node& phaseNode, const std::string& id);
//! Create and install a constant volume pressure dependent
@ -193,12 +112,10 @@ public:
* - It also creates a PDSS object, which basically contains a
* duplication of some of this information and returns a pointer to
* the new object.
* .
*
* @param k Species index within the phase
* @param speciesNode Reference to the species node in the XML tree
* @param phaseNode_ptr Pointer to the phase node in the XML tree
*
* @return Returns a pointer to the a newly malloced PDSS object
* containing the parameterization
*/
@ -206,24 +123,10 @@ public:
const XML_Node* const phaseNode_ptr);
//@}
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of ss properties
/*!
*
*/
virtual VPSSMgr_enumType reportVPSSMgrType() const ;
};
//@}
}
#endif

248
include/cantera/thermo/VPSSMgr_General.h
View file

@ -26,32 +26,26 @@ class VPStandardStateTP;
class SpeciesThermo;
class PDSS;
//! Class that handles the calculation of standard state thermo properties for
//! a set of species belonging to a single phase in a completely general
//! but slow way.
/*!
* This class manages the calculation of standard state thermo properties for
* a set of species belonging to a single phase in a completely general
* but slow way.
* The way this does this is to call the underlying PDSS routines one at a
* time for every species.
* This class manages the calculation of standard state thermo properties
* for a set of species belonging to a single phase in a completely general
* but slow way. The way this does this is to call the underlying PDSS
* routines one at a time for every species.
*
* @ingroup mgrpdssthermocalc
*/
class VPSSMgr_General : public VPSSMgr
{
public:
//! Constructor
/*!
* @param vp_ptr Pointer to the owning VPStandardStateTP object
* for the phase. It's a requirement that this be
* already malloced.
* @param spth Pointer to the SpeciesThermo object for the
* phase. It's a requirement that this be already
* malloced.
* @param vp_ptr Pointer to the owning VPStandardStateTP object for the
* phase. It's a requirement that this be already malloced.
* @param spth Pointer to the SpeciesThermo object for the phase. It's
* a requirement that this be already malloced.
*/
VPSSMgr_General(VPStandardStateTP* vp_ptr,
SpeciesThermo* spth);
@ -59,233 +53,103 @@ public:
//! Destructor
virtual ~VPSSMgr_General();
//! Copy Constructor for the %SpeciesThermo object.
/*!
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Copy Constructor
VPSSMgr_General(const VPSSMgr_General& right);
//! Assignment operator for the %SpeciesThermo object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr_General& operator=(const VPSSMgr_General& right);
//! Duplication routine for objects which inherit from
//! %VPSSSpeciesThermo
/*!
* This virtual routine can be used to duplicate %VPSSSpeciesThermo objects
* inherited from %VPSSSpeciesThermo even if the application only has
* a pointer to %VPSSSpeciesThermo to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
protected:
/*!
* @name Properties of the Standard State of the Species in the Solution
*
* Within VPStandardStateTP, these properties are calculated via a common routine,
* _updateStandardStateThermo(),
* which must be overloaded in inherited objects.
* The values are cached within this object, and are not recalculated unless
* the temperature or pressure changes.
* Within VPStandardStateTP, these properties are calculated via a common
* routine, _updateStandardStateThermo(), which must be overloaded in
* inherited objects. The values are cached within this object, and are
* not recalculated unless the temperature or pressure changes.
*/
//@{
protected:
//! Internally updates the standard state thermodynamic functions at the current
//! T and P of the solution.
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called whenever the temperature or pressure
* has changed.
*
* This function is responsible for updating the following internal members,
* when m_useTmpStandardStateStorage is true.
*
* - m_hss_RT;
* - m_cpss_R;
* - m_gss_RT;
* - m_sss_R;
* - m_Vss
*
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called every time information is requested from
* this object.
*
* Underscore updates never check for the state of the system
* They just do the calculation.
*/
virtual void _updateStandardStateThermo();
//! Updates the reference state thermodynamic functions at the
//! current T of the solution and the reference pressure
/*!
* Underscore updates never check for the state of the system
* They just do the calculation.
*/
virtual void _updateRefStateThermo() const;
//@}
/// @name Thermodynamic Values for the Species Reference States (VPStandardStateTP)
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
/*! @name Thermodynamic Values for the Species Reference States
* There are also temporary variables for holding the species reference-
* state values of Cp, H, S, and V at the last temperature and reference
* pressure called. These functions are not recalculated if a new call is
* made using the previous temperature. All calculations are done within
* the routine _updateRefStateThermo().
*/
//@{
/*!
* Returns the vector of the
* gibbs function of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* units = J/kmol
*
* @param g Output vector contain the Gibbs free energies
* of the reference state of the species
* length = m_kk, units = J/kmol.
*/
virtual void getGibbs_ref(doublereal* g) const ;
//@}
//! @name Initialization Methods - For Internal use (VPStandardState)
/*!
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally used in application programs.
* To see how they are used, see files importCTML.cpp and
* ThermoFactory.cpp.
/*! @name Initialization Methods - For Internal use
* The following methods are used in the process of constructing the phase
* and setting its parameters from a specification in an input file. They
* are not normally used in application programs. To see how they are
* used, see files importCTML.cpp and ThermoFactory.cpp.
*/
//@{
//! @internal Initialize the object
/*!
* This method is provided to allow
* subclasses to perform any initialization required after all
* species have been added. For example, it might be used to
* resize internal work arrays that must have an entry for
* each species. The base class implementation does nothing,
* and subclasses that do not require initialization do not
* need to overload this method. When importing a CTML phase
* description, this method is called just prior to returning
* from function importPhase().
*
* @see importCTML.cpp
*/
virtual void initThermo();
//! Finalize the thermo objects after all species have been entered
/*!
* This function is the LAST initialization routine to be
* called. It's called after createInstallPDSS() has been
* called for each species in the phase, and after initThermo()
* has been called.
* It's called via an inner-to-outer onion-shell like manner.
*
* Currently, this routine passed control to the parent class
* without doing anything.
*
* @param phaseNode Reference to the phaseNode XML node.
* @param id ID of the phase.
*/
virtual void initThermoXML(XML_Node& phaseNode, const std::string& id);
//@}
private:
//! Local factory routine for the creation of PDSS objects
/*!
* This routine is specific to the VPSSMgr_General object.
* It will create a PDSS object for species k, by searching
* and querying for the "standardState" XML node in the standard
* state description of the species. If this XML node doesn't
* exist, it will assume that the standard state is an ideal
* gas.
* It decides on the attribute, "model", what PDSS object
* to create.
* This routine is specific to the VPSSMgr_General object. It will create
* a PDSS object for species k, by searching and querying for the
* "standardState" XML node in the standard state description of the
* species. If this XML node doesn't exist, it will assume that the
* standard state is an ideal gas. It decides on the attribute, "model",
* what PDSS object to create.
*
* @param k Species number
* @param speciesNode XML node for the standard state of the species
* @param phaseNode_ptr pointer to the phase XML node
* @param doST output variable indicating whether the
* instantiation has resulted in a SpeciesThermo object
* being created and registered with the SpeciesThermo
* manager class.
*
* @return Returns the pointer to a malloced PDSS object
* @param speciesNode XML node for the standard state of the species
* @param k Species number
* @param phaseNode_ptr pointer to the phase XML node
* @param doST output variable indicating whether the
* instantiation has resulted in a SpeciesThermo object
* being created and registered with the SpeciesThermo
* manager class.
* @return Returns the pointer to a malloced PDSS object
*/
PDSS* returnPDSS_ptr(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr, bool& doST);
public:
//! Factory routine for the creation of PDSS objects that are
//! then internally registered with this VPSSMgr object
/*!
* This function sets up the internal data within this object for
* handling the calculation of the standard state for the species.
* This function sets up the internal data within this object for handling
* the calculation of the standard state for the species.
*
* This routine
* will create a PDSS object for species k, by searching
* and querying for the "standardState" XML node in the standard
* state description of the species.
* It will then store the object's pointer in a vector of pointers,
* and it will own the object.
* This routine will create a PDSS object for species k, by searching and
* querying for the "standardState" XML node in the standard state
* description of the species. It will then store the object's pointer in
* a vector of pointers, and it will own the object.
*
* @param k Species number
* @param speciesNode XML node for the standard state of the species
* @param phaseNode_ptr pointer to the phase XML node
*
* @return Returns the pointer to the malloced PDSS object
* @param k Species number
* @param speciesNode XML node for the standard state of the species
* @param phaseNode_ptr pointer to the phase XML node
* @return Returns the pointer to the malloced PDSS object
*/
virtual PDSS* createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr);
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of the standard state properties
/*!
*
*/
virtual VPSSMgr_enumType reportVPSSMgrType() const ;
//! Initialize the internal shallow pointers in this object
/*!
* There are a bunch of internal shallow pointers that point to the owning
* VPStandardStateTP and SpeciesThermo objects. This function reinitializes
* them. This function is called like an onion.
*
* @param vp_ptr Pointer to the VPStandardStateTP standard state
* @param sp_ptr Pointer to the SpeciesThermo standard state
*/
virtual void initAllPtrs(VPStandardStateTP* vp_ptr, SpeciesThermo* sp_ptr);
private:
//! Shallow pointers containing the PDSS objects for the species
//! in this phase.
/*!
* This object doesn't own these pointers.
*/
//! in this phase. This object doesn't own these pointers.
std::vector<PDSS*> m_PDSS_ptrs;
};
//@}
}
#endif

156
include/cantera/thermo/VPSSMgr_IdealGas.h
View file

@ -27,24 +27,10 @@ class VPStandardStateTP;
class SpeciesThermo;
//! Virtual base class for the species thermo manager classes.
/*!
* This class defines the interface which all subclasses must implement.
*
* Class %VPSSSpeciesThermo is the base class
* for a family of classes that compute properties of a set of
* species in their reference state at a range of temperatures.
* Note, the pressure dependence of the reference state is not
* handled by this particular species standard state model.
*
* @ingroup mgrpdssthermocalc
*/
//! A VPSSMgr where all species in the phase obey an ideal gas equation of state
class VPSSMgr_IdealGas : public VPSSMgr
{
public:
//! Basic constructor that initializes the object
/*!
* @param vp_ptr Pointer to the owning ThermoPhase
@ -55,133 +41,43 @@ public:
//! Destructor
virtual ~VPSSMgr_IdealGas();
//! Copy Constructor for the %SpeciesThermo object.
/*!
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Copy Constructor
VPSSMgr_IdealGas(const VPSSMgr_IdealGas& right);
//! Assignment operator for the %SpeciesThermo object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr_IdealGas& operator=(const VPSSMgr_IdealGas& right);
//! Duplication routine for objects which inherit from
//! %VPSSSpeciesThermo
/*!
* This virtual routine can be used to duplicate %VPSSSpeciesThermo objects
* inherited from %VPSSSpeciesThermo even if the application only has
* a pointer to %VPSSSpeciesThermo to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
/*!
* @name Properties of the Standard State of the Species in the Solution
*
* Within VPStandardStateTP, these properties are calculated via a common routine,
* _updateStandardStateThermo(),
* which must be overloaded in inherited objects.
* The values are cached within this object, and are not recalculated unless
* the temperature or pressure changes.
/*! @name Properties of the Standard State of the Species in the Solution
* Within VPStandardStateTP, these properties are calculated via a common
* routine, _updateStandardStateThermo(), which must be overloaded in
* inherited objects. The values are cached within this object, and are
* not recalculated unless the temperature or pressure changes.
*/
//@{
/**
* Returns the vector of nondimensional
* internal Energies of the standard state at the current temperature
* and pressure of the solution for each species.
* \f[
* u^{ss}_k(T,P) = h^{ss}_k(T) - P * V^{ss}_k
* \f]
*
* @param urt Output vector of nondimensional standard state
* internal energies. length = m_kk.
*/
virtual void getIntEnergy_RT(doublereal* urt) const;
/**
* Get the molar volumes of each species in their standard
* states at the current
* <I>T</I> and <I>P</I> of the solution.
* units = m^3 / kmol
*
* This is redefined here to call the internal function, _updateStandardStateThermo(),
* which calculates all standard state properties at the same time.
*
* @param vol Output vector of species volumes. length = m_kk.
* units = m^3 / kmol
*/
virtual void getStandardVolumes(doublereal* vol) const;
//@}
protected:
//! Updates the standard state thermodynamic functions at the current
//! T and P of the solution.
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called every time the temperature or pressure
* has changed.
*
* This function is responsible for updating the following internal members,
* when m_useTmpStandardStateStorage is true.
*
* - m_hss_RT;
* - m_cpss_R;
* - m_gss_RT;
* - m_sss_R;
* - m_Vss
*
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called everytime this class is invoked.
*
*/
virtual void _updateStandardStateThermo();
public:
//@}
/// @name Thermodynamic Values for the Species Reference States (VPStandardStateTP)
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
/*! @name Initialization Methods - For Internal use
* The following methods are used in the process of constructing the phase
* and setting its parameters from a specification in an input file. They
* are not normally used in application programs. To see how they are
* used, see files importCTML.cpp and ThermoFactory.cpp.
*/
//@{
//! @name Initialization Methods - For Internal use (VPStandardState)
/*!
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally used in application programs.
* To see how they are used, see files importCTML.cpp and
* ThermoFactory.cpp.
*
*/
//@{
//! Initialize the thermo for this standard state thermo calculator
/*!
* This task is done last, after createInstallPDSS() and after
* initThermo().
*
* @param phaseNode Reference to the phase node in the XML tree
* @param id string name of the phase
*/
virtual void initThermoXML(XML_Node& phaseNode, const std::string& id);
//@}
//! Create and install an ideal gas standard state manager
//! for one species within this object
//! Create and install an ideal gas standard state manager for one species
//! within this object
/*!
* This function sets up the internal data within this object for
* handling the calculation of the standard state for the species.
@ -195,33 +91,15 @@ public:
* @param k Species index within the phase
* @param speciesNode Reference to the species node in the XML tree
* @param phaseNode_ptr Pointer to the phase node in the XML tree
*
* @return Returns a pointer to the a newly malloced PDSS object
* containing the parameterization
*/
virtual PDSS* createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr);
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of standard state properties
/*!
*
*/
virtual VPSSMgr_enumType reportVPSSMgrType() const ;
};
//@}
}
#endif

243
include/cantera/thermo/VPSSMgr_Water_ConstVol.h
View file

@ -27,23 +27,12 @@ class SpeciesThermo;
class PDSS;
class PDSS_Water;
//! Virtual base class for the species thermo manager classes.
/*!
* This class defines the interface which all subclasses must implement.
*
* Class %VPSSSpeciesThermo is the base class
* for a family of classes that compute properties of a set of
* species in their reference state at a range of temperatures.
* Note, the pressure dependence of the reference state is not
* handled by this particular species standard state model.
*
* @ingroup mgrpdssthermocalc
*/
//! Handles the calculation of standard state thermo properties for real water
//! and a set of species which have a constant molar volume pressure
//! dependence.
class VPSSMgr_Water_ConstVol : public VPSSMgr
{
public:
//! Base Constructor
/*!
* Initialize the object.
@ -56,267 +45,75 @@ public:
//! Destructor
virtual ~VPSSMgr_Water_ConstVol();
//! Copy Constructor for the %SpeciesThermo object.
/*!
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Copy Constructor
VPSSMgr_Water_ConstVol(const VPSSMgr_Water_ConstVol& right);
//! Assignment operator for the %SpeciesThermo object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr_Water_ConstVol& operator=(const VPSSMgr_Water_ConstVol& right);
//! Duplication routine for objects which inherit from
//! %VPSSSpeciesThermo
/*!
* This virtual routine can be used to duplicate %VPSSSpeciesThermo objects
* inherited from %VPSSSpeciesThermo even if the application only has
* a pointer to %VPSSSpeciesThermo to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
private:
/*!
* @name Properties of the Standard State of the Species in the Solution
*
* Within VPStandardStateTP, these properties are calculated via a common routine,
* _updateStandardStateThermo(),
* which must be overloaded in inherited objects.
* The values are cached within this object, and are not recalculated unless
* the temperature or pressure changes.
* Within VPStandardStateTP, these properties are calculated via a common
* routine, _updateStandardStateThermo(), which must be overloaded in
* inherited objects. The values are cached within this object, and are
* not recalculated unless the temperature or pressure changes.
*/
//@{
private:
//! Updates the standard state thermodynamic functions at the current T and P of the solution.
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called for every call to functions in this
* class. It checks to see whether the temperature or pressure has changed and
* thus the ss thermodynamics functions for all of the species
* must be recalculated.
*
* This function is responsible for updating the following internal members,
*
* - m_hss_RT;
* - m_cpss_R;
* - m_gss_RT;
* - m_sss_R;
* - m_Vss
*
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called by child classes to update internal member data.
*
* Note, this will throw an error. It must be reimplemented in derived classes.
*
*/
virtual void _updateStandardStateThermo();
//! Updates the reference state thermodynamic functions at the
//! current T of the solution and the reference pressure
/*!
* Underscore updates never check for the state of the system.
* They just do the calculation.
*
* This function is responsible for updating the following internal members
*
* - m_h0_RT;
* - m_cp0_R;
* - m_g0_RT;
* - m_s0_R;
* - m_V0
*
* This routine also updates all of the thermo to the current temperature
*/
virtual void _updateRefStateThermo() const;
//@}
public:
/// @name Thermodynamic Values for the Species Reference States (VPStandardStateTP)
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
*/
/*! @name Thermodynamic Values for the Species Reference States
* There are also temporary variables for holding the species reference-
* state values of Cp, H, S, and V at the last temperature and reference
* pressure called. These functions are not recalculated if a new call is
* made using the previous temperature. All calculations are done within
* the routine _updateRefStateThermo().
*/
//@{
/*!
* Returns the vector of nondimensional
* enthalpies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param hrt Output vector contains the nondimensional enthalpies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
virtual void getEnthalpy_RT_ref(doublereal* hrt) const;
/*!
* Returns the vector of nondimensional
* Gibbs free energies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param grt Output vector contains the nondimensional Gibbs free energies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
virtual void getGibbs_RT_ref(doublereal* grt) const ;
/*!
* Returns the vector of the
* gibbs function of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* units = J/kmol
*
* @param g Output vector contain the Gibbs free energies
* of the reference state of the species
* length = m_kk, units = J/kmol.
*/
virtual void getGibbs_ref(doublereal* g) const ;
/*!
* Returns the vector of nondimensional
* entropies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param er Output vector contain the nondimensional entropies
* of the species in their reference states
* length: m_kk, units: dimensionless.
*/
virtual void getEntropy_R_ref(doublereal* er) const ;
/*!
* Returns the vector of nondimensional
* constant pressure heat capacities of the reference state
* at the current temperature of the solution
* and reference pressure for the species.
*
* @param cpr Output vector contains the nondimensional heat capacities
* of the species in their reference states
* length: m_kk, units: dimensionless.
*/
virtual void getCp_R_ref(doublereal* cpr) const ;
//! Get the molar volumes of the species reference states at the current
//! <I>T</I> and <I>P_ref</I> of the solution.
/*!
* units = m^3 / kmol
*
* @param vol Output vector containing the standard state volumes.
* Length: m_kk.
*/
virtual void getStandardVolumes_ref(doublereal* vol) const ;
//! @name Initialization Methods - For Internal use (VPStandardState)
/*!
//! @}
/*! @name Initialization Methods - For Internal use
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally used in application programs.
* To see how they are used, see files importCTML.cpp and
* ThermoFactory.cpp.
*/
//@{
//! @internal Initialize the object
/*!
* This method is provided to allow
* subclasses to perform any initialization required after all
* species have been added. For example, it might be used to
* resize internal work arrays that must have an entry for
* each species. The base class implementation does nothing,
* and subclasses that do not require initialization do not
* need to overload this method. When importing a CTML phase
* description, this method is called just prior to returning
* from function importPhase().
*
* @see importCTML.cpp
*/
//! Initialize the thermo, after all species have been entered.
virtual void initThermo();
//! Finalize the thermo after all species have been entered
/*!
* This function is the LAST initialization routine to be
* called. It's called after createInstallPDSS() has been
* called for each species in the phase, and after initThermo()
* has been called.
* It's called via an inner-to-outer onion shell like manner.
*
*
* @param phaseNode Reference to the phaseNode XML node.
* @param id ID of the phase.
*/
virtual void initThermoXML(XML_Node& phaseNode, const std::string& id);
//@}
//! Install specific content for species k in the standard-state
//! thermodynamic calculator and also create/return a PDSS object
//! for that species.
/*!
* This occurs before matrices are sized appropriately.
*
* @param k Species index in the phase
* @param speciesNode XML Node corresponding to the species
* @param phaseNode_ptr Pointer to the XML Node corresponding
* to the phase which owns the species
*/
virtual PDSS* createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr);
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of ss properties
/*!
* @return Returns an enumerated type that is unique.
*/
virtual VPSSMgr_enumType reportVPSSMgrType() const ;
//! Initialize all internal pointers
/*!
* This is a virtual function that fills or updates the values of the
* shallow pointers.
*
* @param vp_ptr Pointer to the Variable Pressure standard state object
* @param sp_ptr Pointer to the reference state thermo calculator object
*/
virtual void initAllPtrs(VPStandardStateTP* vp_ptr, SpeciesThermo* sp_ptr);
private:
//! Pointer to the Water PDSS object.
/*!
* This is a shallow copy. The water PDSS object is owned by the VPStandardStateTP
* object.
*/
PDSS_Water* m_waterSS;
};
//@}
}
#endif

277
include/cantera/thermo/VPSSMgr_Water_HKFT.h
View file

@ -26,24 +26,11 @@ class SpeciesThermo;
class PDSS;
class PDSS_Water;
//! Virtual base class for the species thermo manager classes.
/*!
* This class defines the interface which all subclasses must implement.
*
* Class %VPSSSpeciesThermo is the base class
* for a family of classes that compute properties of a set of
* species in their reference state at a range of temperatures.
* Note, the pressure dependence of the reference state is not
* handled by this particular species standard state model.
*
* @ingroup mgrpdssthermocalc
*/
//! Manages standard state thermo properties for real water and a set of
//! species which have the HKFT equation of state.
class VPSSMgr_Water_HKFT : public VPSSMgr
{
public:
//! Constructor
/*!
* @param vptp_ptr Pointer to the Variable pressure %ThermoPhase object
@ -59,147 +46,36 @@ public:
//! Destructor
virtual ~VPSSMgr_Water_HKFT();
//! Copy Constructor for the %SpeciesThermo object.
/*!
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Copy Constructor
VPSSMgr_Water_HKFT(const VPSSMgr_Water_HKFT& right);
//! Assignment operator for the %SpeciesThermo object
/*!
* This is NOT a virtual function.
*
* @param right Reference to %SpeciesThermo object to be copied into the
* current one.
*/
//! Assignment operator
VPSSMgr_Water_HKFT& operator=(const VPSSMgr_Water_HKFT& right);
//! Duplication routine for objects which inherit from
//! %VPSSSpeciesThermo
/*!
* This virtual routine can be used to duplicate %VPSSSpeciesThermo objects
* inherited from %VPSSSpeciesThermo even if the application only has
* a pointer to %VPSSSpeciesThermo to work with.
*/
virtual VPSSMgr* duplMyselfAsVPSSMgr() const;
/*!
* @name Properties of the Standard State of the Species in the Solution
*
* Within VPStandardStateTP, these properties are calculated via a common routine,
* _updateStandardStateThermo(),
* which must be overloaded in inherited objects.
* The values are cached within this object, and are not recalculated unless
* the temperature or pressure changes.
/*! @name Thermodynamic Values for the Species Reference States
* There are also temporary variables for holding the species reference-
* state values of Cp, H, S, and V at the last temperature and reference
* pressure called. These functions are not recalculated if a new call is
* made using the previous temperature. All calculations are done within
* the routine _updateRefStateThermo().
*/
//@{
//@}
/// @name Thermodynamic Values for the Species Reference States (VPStandardStateTP)
/*!
* There are also temporary
* variables for holding the species reference-state values of Cp, H, S, and V at the
* last temperature and reference pressure called. These functions are not recalculated
* if a new call is made using the previous temperature.
* All calculations are done within the routine _updateRefStateThermo().
*/
//@{
/*!
* Returns the vector of nondimensional
* enthalpies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param hrt Output vector contains the nondimensional enthalpies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
virtual void getEnthalpy_RT_ref(doublereal* hrt) const;
/*!
* Returns the vector of nondimensional
* Gibbs free energies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param grt Output vector contains the nondimensional Gibbs free energies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
virtual void getGibbs_RT_ref(doublereal* grt) const ;
/*!
* Returns the vector of the
* gibbs function of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* units = J/kmol
*
* @param g Output vector contain the Gibbs free energies
* of the reference state of the species
* length = m_kk, units = J/kmol.
*/
virtual void getGibbs_ref(doublereal* g) const ;
/*!
* Returns the vector of nondimensional
* entropies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param er Output vector contain the nondimensional entropies
* of the species in their reference states
* length: m_kk, units: dimensionless.
*/
virtual void getEntropy_R_ref(doublereal* er) const ;
/*!
* Returns the vector of nondimensional
* constant pressure heat capacities of the reference state
* at the current temperature of the solution
* and reference pressure for the species.
*
* @param cpr Output vector contains the nondimensional heat capacities
* of the species in their reference states
* length: m_kk, units: dimensionless.
*/
virtual void getCp_R_ref(doublereal* cpr) const ;
//! Get the molar volumes of the species reference states at the current
//! <I>T</I> and <I>P_ref</I> of the solution.
/*!
* units = m^3 / kmol
*
* @param vol Output vector containing the standard state volumes.
* Length: m_kk.
*/
virtual void getStandardVolumes_ref(doublereal* vol) const ;
//@}
//! Set the temperature (K) and pressure (Pa)
/*!
* This sets the temperature and pressure and triggers
* calculation of underlying quantities
*
* @param T Temperature (K)
* @param P Pressure (Pa)
*/
virtual void setState_TP(doublereal T, doublereal P);
//! Set the temperature (K)
/*!
* @param T Temperature (K)
*/
virtual void setState_T(doublereal T);
//! Set the pressure (Pa)
/*!
* @param P Pressure (Pa)
*/
virtual void setState_P(doublereal P);
//@}
/// @name Setting the Internal State of the System
/*!
/*! @name Setting the Internal State of the System
* All calls to change the internal state of the system's T and P
* are done through these routines
* - setState_TP()
@ -217,100 +93,23 @@ public:
* these to get derivatives.
*/
//@{
//! Updates the internal reference state thermodynamic vectors at the
//! current T of the solution and the reference pressure.
/*!
* This is called to make sure that the internal thermodynamic members
* are up-to-date. It checks against an internal value of m_tempRef
* to see whether the values are current.
*/
virtual void updateRefStateThermo() const;
private:
//! Updates the reference state thermodynamic functions at the current T
//! and a calculated Pref that is safe.
/*!
*
* This function is responsible for updating the following internal members
*
* - m_h0_RT;
* - m_cp0_R;
* - m_g0_RT;
* - m_s0_R;
* - m_V0
*
* It always does the calculation. No checking is ever done to see
* if the calculation is necessary.
*
* m_p0 is calculated within this routine given the value of the temperature.
* This is necessary because we are using a real equation of state for
* water.
*
* The state of the system is left at (m_tlast, m_plast) at the end
* of the routine.
*/
virtual void _updateRefStateThermo() const;
//! Updates the standard state thermodynamic functions at the current T and P of the solution.
/*!
* @internal
*
* If m_useTmpStandardStateStorage is true,
* this function must be called for every call to functions in this
* class. It checks to see whether the temperature or pressure has changed and
* thus the ss thermodynamics functions for all of the species
* must be recalculated.
*
* This function is responsible for updating the following internal members,
* when m_useTmpStandardStateStorage is true.
*
* - m_hss_RT;
* - m_cpss_R;
* - m_gss_RT;
* - m_sss_R;
* - m_Vss
*
* If m_useTmpStandardStateStorage is not true, this function may be
* required to be called by child classes to update internal member data.
*
* Note, this will throw an error. It must be reimplemented in derived classes.
*
*/
virtual void _updateStandardStateThermo();
//@}
public:
//@}
//! @name Utility Methods - Reports on various quantities
/*!
/*! @name Utility Methods - Reports on various quantities
* The following methods are used in the process of reporting
* various states and attributes
*/
//@{
//! This utility function reports the type of parameterization
//! used for the species with index number index.
/*!
*
* @param index Species index
*/
virtual PDSS_enumType reportPDSSType(int index = -1) const ;
//! This utility function reports the type of manager
//! for the calculation of ss properties
/*!
*
*
*/
virtual VPSSMgr_enumType reportVPSSMgrType() const ;
//@}
//! @name Initialization Methods - For Internal use (VPStandardState)
/*!
/*! @name Initialization Methods - For Internal use (VPStandardState)
* The following methods are used in the process of constructing
* the phase and setting its parameters from a specification in an
* input file. They are not normally used in application programs.
@ -318,55 +117,13 @@ public:
* ThermoFactory.cpp.
*/
//@{
//! @internal Initialize the object
/*!
* This method is provided to allow
* subclasses to perform any initialization required after all
* species have been added. For example, it might be used to
* resize internal work arrays that must have an entry for
* each species. The base class implementation does nothing,
* and subclasses that do not require initialization do not
* need to overload this method. When importing a CTML phase
* description, this method is called just prior to returning
* from function importPhase().
*
* @see importCTML.cpp
*/
virtual void initThermo();
//! Finalize the thermo after all species have been entered
/*!
* This function is the LAST initialization routine to be
* called. It's called after createInstallPDSS() has been
* called for each species in the phase, and after initThermo()
* has been called.
* It's called via an inner-to-outer onion shell like manner.
*
*
* @param phaseNode Reference to the phaseNode XML node.
* @param id ID of the phase.
*/
virtual void initThermoXML(XML_Node& phaseNode, const std::string& id);
//! Install specific content for species k in the standard-state
//! thermodynamic calculator and also create/return a PDSS object
//! for that species.
/*!
* This occurs before matrices are sized appropriately.
*
* @param k Species index in the phase
* @param speciesNode XML Node corresponding to the species
* @param phaseNode_ptr Pointer to the XML Node corresponding
* to the phase which owns the species
*/
virtual PDSS* createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr);
//@}
private:
//! Shallow pointer to the water object
PDSS_Water* m_waterSS;
@ -377,8 +134,6 @@ private:
*/
mutable doublereal m_tlastRef;
};
//@}
}
#endif

19
src/thermo/VPSSMgr.cpp
View file

@ -22,7 +22,6 @@ using namespace std;
namespace Cantera
{
class SpeciesThermo;
VPSSMgr::VPSSMgr(VPStandardStateTP* vptp_ptr, SpeciesThermo* spthermo) :
@ -64,11 +63,6 @@ VPSSMgr::VPSSMgr(const VPSSMgr& right) :
*this = right;
}
//====================================================================================================================
/*
* Assigment operator
* We use a shallow copy strategy here. Note, this will have to be fixed up later.
*/
VPSSMgr&
VPSSMgr::operator=(const VPSSMgr& right)
{
@ -122,12 +116,12 @@ VPSSMgr::operator=(const VPSSMgr& right)
return *this;
}
//====================================================================================================================
VPSSMgr* VPSSMgr::duplMyselfAsVPSSMgr() const
{
return new VPSSMgr(*this);
}
//====================================================================================================================
void VPSSMgr::initAllPtrs(VPStandardStateTP* vp_ptr,
SpeciesThermo* sp_ptr)
{
@ -150,7 +144,7 @@ void VPSSMgr::initAllPtrs(VPStandardStateTP* vp_ptr,
}
}
//====================================================================================================================
// Standard States
void
@ -383,9 +377,7 @@ VPSSMgr::initLengths()
m_sss_R.resize(m_kk, 0.0);
m_Vss.resize(m_kk, 0.0);
// Storage used by the PDSS objects to store their
// answers.
// Storage used by the PDSS objects to store their answers.
mPDSS_h0_RT.resize(m_kk, 0.0);
mPDSS_cp0_R.resize(m_kk, 0.0);
mPDSS_g0_RT.resize(m_kk, 0.0);
@ -463,7 +455,6 @@ PDSS* VPSSMgr::createInstallPDSS(size_t k, const XML_Node& s,
return (PDSS*) 0;
}
/*****************************************************************/
doublereal VPSSMgr::minTemp(size_t k) const
{
@ -512,5 +503,3 @@ void VPSSMgr::err(const std::string& msg) const
throw CanteraError("VPSSMgr::" + msg, "unimplemented");
}
}

27
src/thermo/VPSSMgr_ConstVol.cpp
View file

@ -59,9 +59,6 @@ VPSSMgr* VPSSMgr_ConstVol::duplMyselfAsVPSSMgr() const
}
/*
* Get the nondimensional Entropies for the species
* standard states at the current T and P of the solution.
*
* Note, this is equal to the reference state entropies
* due to the zero volume expansivity:
* i.e., (dS/dp)_T = (dV/dT)_P = 0.0
@ -80,15 +77,6 @@ void VPSSMgr_ConstVol::_updateStandardStateThermo()
}
}
/*
* Returns the vector of nondimensional
* Gibbs free energies of the reference state at the current temperature
* of the solution and the reference pressure for the species.
*
* @param grt Output vector contains the nondimensional Gibbs free energies
* of the reference state of the species
* length = m_kk, units = dimensionless.
*/
void VPSSMgr_ConstVol::getGibbs_RT_ref(doublereal* grt) const
{
if (m_useTmpRefStateStorage) {
@ -99,15 +87,6 @@ void VPSSMgr_ConstVol::getGibbs_RT_ref(doublereal* grt) const
}
}
// Get the molar volumes of the species reference states at the current
// <I>T</I> and <I>P_ref</I> of the solution.
/*
* units = m^3 / kmol
*
* @param vol Output vector containing the standard state volumes.
* Length: m_kk.
*/
void VPSSMgr_ConstVol::getStandardVolumes_ref(doublereal* vol) const
{
if (m_useTmpStandardStateStorage) {
@ -153,11 +132,6 @@ VPSSMgr_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id)
}
}
// void
// VPSSMgr_ConstVol::installSpecies(int k, const XML_Node& speciesNode,
// const XML_Node *phaseNode_ptr) {
//}
PDSS*
VPSSMgr_ConstVol::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
@ -197,4 +171,3 @@ VPSSMgr_enumType VPSSMgr_ConstVol::reportVPSSMgrType() const
return cVPSSMGR_CONSTVOL;
}
}

29
src/thermo/VPSSMgr_General.cpp
View file

@ -51,7 +51,7 @@ VPSSMgr_General::VPSSMgr_General(const VPSSMgr_General& right) :
m_useTmpRefStateStorage = true;
*this = right;
}
//====================================================================================================================
VPSSMgr_General& VPSSMgr_General::operator=(const VPSSMgr_General& b)
{
if (&b == this) {
@ -75,16 +75,7 @@ VPSSMgr* VPSSMgr_General::duplMyselfAsVPSSMgr() const
{
return new VPSSMgr_General(*this);
}
//====================================================================================================================
// Initialize the internal shallow pointers in this object
/*
* There are a bunch of internal shallow pointers that point to the owning
* VPStandardStateTP and SpeciesThermo objects. This function reinitializes
* them. This function is called like an onion.
*
* @param vp_ptr Pointer to the VPStandardStateTP standard state
* @param sp_ptr Pointer to the SpeciesThermo standard state
*/
void VPSSMgr_General::initAllPtrs(VPStandardStateTP* vp_ptr, SpeciesThermo* sp_ptr)
{
VPSSMgr::initAllPtrs(vp_ptr, sp_ptr);
@ -97,7 +88,7 @@ void VPSSMgr_General::initAllPtrs(VPStandardStateTP* vp_ptr, SpeciesThermo* sp_p
m_PDSS_ptrs[k] = m_vptp_ptr->providePDSS(k);
}
}
//====================================================================================================================
void VPSSMgr_General::_updateRefStateThermo() const
{
if (m_useTmpRefStateStorage) {
@ -126,22 +117,11 @@ void VPSSMgr_General::_updateStandardStateThermo()
}
}
void VPSSMgr_General::initThermo()
{
initLengths();
}
/*!
* Returns the vector of the
* gibbs function of the reference state at the current temperature
* of the solution and the reference pressure for the species.
* units = J/kmol
*
* @param g Output vector contain the Gibbs free energies
* of the reference state of the species
* length = m_kk, units = J/kmol.
*/
void VPSSMgr_General::getGibbs_ref(doublereal* g) const
{
doublereal _rt = GasConstant * m_tlast;
@ -269,11 +249,8 @@ PDSS_enumType VPSSMgr_General::reportPDSSType(int k) const
return kPDSS->reportPDSSType();
}
VPSSMgr_enumType VPSSMgr_General::reportVPSSMgrType() const
{
return cVPSSMGR_GENERAL;
}
}

4
src/thermo/VPSSMgr_IdealGas.cpp
View file

@ -44,7 +44,6 @@ VPSSMgr_IdealGas::VPSSMgr_IdealGas(const VPSSMgr_IdealGas& right) :
*this = right;
}
VPSSMgr_IdealGas& VPSSMgr_IdealGas::operator=(const VPSSMgr_IdealGas& b)
{
if (&b == this) {
@ -59,7 +58,6 @@ VPSSMgr* VPSSMgr_IdealGas::duplMyselfAsVPSSMgr() const
return new VPSSMgr_IdealGas(*this);
}
void VPSSMgr_IdealGas::getIntEnergy_RT(doublereal* urt) const
{
getEnthalpy_RT(urt);
@ -122,13 +120,11 @@ VPSSMgr_IdealGas::createInstallPDSS(size_t k, const XML_Node& speciesNode,
return kPDSS;
}
PDSS_enumType VPSSMgr_IdealGas::reportPDSSType(int k) const
{
return cPDSS_IDEALGAS;
}
VPSSMgr_enumType VPSSMgr_IdealGas::reportVPSSMgrType() const
{
return cVPSSMGR_IDEALGAS;

11
src/thermo/VPSSMgr_Water_ConstVol.cpp
View file

@ -23,7 +23,6 @@ using namespace std;
namespace Cantera
{
VPSSMgr_Water_ConstVol::VPSSMgr_Water_ConstVol(VPStandardStateTP* vp_ptr,
SpeciesThermo* spth) :
VPSSMgr(vp_ptr, spth),
@ -33,7 +32,6 @@ VPSSMgr_Water_ConstVol::VPSSMgr_Water_ConstVol(VPStandardStateTP* vp_ptr,
m_useTmpStandardStateStorage = true;
}
VPSSMgr_Water_ConstVol::~VPSSMgr_Water_ConstVol()
{
}
@ -46,7 +44,6 @@ VPSSMgr_Water_ConstVol::VPSSMgr_Water_ConstVol(const VPSSMgr_Water_ConstVol& rig
*this = right;
}
VPSSMgr_Water_ConstVol&
VPSSMgr_Water_ConstVol::operator=(const VPSSMgr_Water_ConstVol& b)
{
@ -75,7 +72,6 @@ VPSSMgr_Water_ConstVol::initAllPtrs(VPStandardStateTP* vp_ptr,
}
}
void
VPSSMgr_Water_ConstVol::getEnthalpy_RT_ref(doublereal* hrt) const
{
@ -182,11 +178,8 @@ void VPSSMgr_Water_ConstVol::_updateRefStateThermo() const
m_waterSS->setState_TP(m_tlast, m_plast);
}
void VPSSMgr_Water_ConstVol::_updateStandardStateThermo()
{
doublereal RT = GasConstant * m_tlast;
doublereal del_pRT = (m_plast - OneAtm) / (RT);
@ -208,7 +201,6 @@ void VPSSMgr_Water_ConstVol::_updateStandardStateThermo()
m_Vss[0] = (m_vptp_ptr->molecularWeight(0) / m_waterSS->density());
}
void VPSSMgr_Water_ConstVol::initThermo()
{
VPSSMgr::initThermo();
@ -260,7 +252,6 @@ PDSS*
VPSSMgr_Water_ConstVol::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
{
PDSS* kPDSS = 0;
// Will have to do something for water
// -> make sure it's species 0
@ -322,5 +313,3 @@ VPSSMgr_enumType VPSSMgr_Water_ConstVol::reportVPSSMgrType() const
return cVPSSMGR_WATER_CONSTVOL;
}
}

2
src/thermo/VPSSMgr_Water_HKFT.cpp
View file

@ -315,5 +315,3 @@ VPSSMgr_enumType VPSSMgr_Water_HKFT::reportVPSSMgrType() const
return cVPSSMGR_WATER_HKFT;
}
}