diff --git a/include/cantera/thermo/VPSSMgr.h b/include/cantera/thermo/VPSSMgr.h index 6c5bdd857..5991a37ca 100644 --- a/include/cantera/thermo/VPSSMgr.h +++ b/include/cantera/thermo/VPSSMgr.h @@ -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 - - . . . - - - <\thermo> - . . . - <\phase> - @endverbatim + * @code + * + * . . . + * + * + * <\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 - - . . . - - - <\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 + * + * . . . + * + * + * <\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 - * T and P 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 T and P 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 - //! T and P 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 - //! T and P_ref 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; - }; //@} } diff --git a/include/cantera/thermo/VPSSMgr_ConstVol.h b/include/cantera/thermo/VPSSMgr_ConstVol.h index 7c518ccc4..5900844c3 100644 --- a/include/cantera/thermo/VPSSMgr_ConstVol.h +++ b/include/cantera/thermo/VPSSMgr_ConstVol.h @@ -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 - //! T and P_ref 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 diff --git a/include/cantera/thermo/VPSSMgr_General.h b/include/cantera/thermo/VPSSMgr_General.h index ae39523ea..e56959e37 100644 --- a/include/cantera/thermo/VPSSMgr_General.h +++ b/include/cantera/thermo/VPSSMgr_General.h @@ -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 m_PDSS_ptrs; }; -//@} + } #endif - diff --git a/include/cantera/thermo/VPSSMgr_IdealGas.h b/include/cantera/thermo/VPSSMgr_IdealGas.h index 4540a86c3..22bd145c0 100644 --- a/include/cantera/thermo/VPSSMgr_IdealGas.h +++ b/include/cantera/thermo/VPSSMgr_IdealGas.h @@ -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 - * 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. - * - * @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 - diff --git a/include/cantera/thermo/VPSSMgr_Water_ConstVol.h b/include/cantera/thermo/VPSSMgr_Water_ConstVol.h index bd09f7386..487af9dc4 100644 --- a/include/cantera/thermo/VPSSMgr_Water_ConstVol.h +++ b/include/cantera/thermo/VPSSMgr_Water_ConstVol.h @@ -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 - //! T and P_ref 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 - diff --git a/include/cantera/thermo/VPSSMgr_Water_HKFT.h b/include/cantera/thermo/VPSSMgr_Water_HKFT.h index 48582890e..c2c98b4fc 100644 --- a/include/cantera/thermo/VPSSMgr_Water_HKFT.h +++ b/include/cantera/thermo/VPSSMgr_Water_HKFT.h @@ -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 - //! T and P_ref 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 - diff --git a/src/thermo/VPSSMgr.cpp b/src/thermo/VPSSMgr.cpp index 9eef00528..d15824a90 100644 --- a/src/thermo/VPSSMgr.cpp +++ b/src/thermo/VPSSMgr.cpp @@ -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"); } } - - diff --git a/src/thermo/VPSSMgr_ConstVol.cpp b/src/thermo/VPSSMgr_ConstVol.cpp index 8f656133c..3132f032a 100644 --- a/src/thermo/VPSSMgr_ConstVol.cpp +++ b/src/thermo/VPSSMgr_ConstVol.cpp @@ -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 -// T and P_ref 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; } } - diff --git a/src/thermo/VPSSMgr_General.cpp b/src/thermo/VPSSMgr_General.cpp index ea97c5c86..734b783ac 100644 --- a/src/thermo/VPSSMgr_General.cpp +++ b/src/thermo/VPSSMgr_General.cpp @@ -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; } } - - diff --git a/src/thermo/VPSSMgr_IdealGas.cpp b/src/thermo/VPSSMgr_IdealGas.cpp index 36dd84462..ac424123f 100644 --- a/src/thermo/VPSSMgr_IdealGas.cpp +++ b/src/thermo/VPSSMgr_IdealGas.cpp @@ -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; diff --git a/src/thermo/VPSSMgr_Water_ConstVol.cpp b/src/thermo/VPSSMgr_Water_ConstVol.cpp index 393134564..746625525 100644 --- a/src/thermo/VPSSMgr_Water_ConstVol.cpp +++ b/src/thermo/VPSSMgr_Water_ConstVol.cpp @@ -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; } } - - diff --git a/src/thermo/VPSSMgr_Water_HKFT.cpp b/src/thermo/VPSSMgr_Water_HKFT.cpp index 9de0b1cbd..4a80cdf0b 100644 --- a/src/thermo/VPSSMgr_Water_HKFT.cpp +++ b/src/thermo/VPSSMgr_Water_HKFT.cpp @@ -315,5 +315,3 @@ VPSSMgr_enumType VPSSMgr_Water_HKFT::reportVPSSMgrType() const return cVPSSMGR_WATER_HKFT; } } - -