PDSS*
VPSSMgr_General::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
{
bool doST;
PDSS* kPDSS = returnPDSS_ptr(k, speciesNode, phaseNode_ptr, doST);
// VPSSMgr::installSTSpecies(k, speciesNode, phaseNode_ptr);
if (m_PDSS_ptrs.size() < k+1) {
m_PDSS_ptrs.resize(k+1, 0);
}
m_PDSS_ptrs[k] = kPDSS;
if ((k+1) >= m_kk) {
m_kk = k+1;
}
doublereal minTemp = kPDSS->minTemp();
if (minTemp > m_minTemp) {
m_minTemp = minTemp;
}
doublereal maxTemp = kPDSS->maxTemp();
if (maxTemp < m_maxTemp) {
m_maxTemp = maxTemp;
}
doublereal p0 = kPDSS->refPressure();
if (k == 0) {
m_p0 = p0;
}
return kPDSS;
}
void VPSSMgr::_updateStandardStateThermo()
{
for (size_t k = 0; k < m_kk; k++) {
PDSS* kPDSS = m_vptp_ptr->providePDSS(k);
kPDSS->setState_TP(m_tlast, m_plast);
}
err("_updateStandardStateThermo()");
}
/*
* Perform initializations after all species have been
* added.
*/
void VPStandardStateTP::initThermo() {
initLengths();
ThermoPhase::initThermo();
m_VPSS_ptr->initThermo();
for (int k = 0; k < m_kk; k++) {
PDSS *kPDSS = m_PDSS_storage[k];
if (kPDSS) {
kPDSS->initThermo();
}
}
}
/*
* Import and initialize a ThermoPhase object
*
* param phaseNode This object must be the phase node of a
* complete XML tree
* description of the phase, including all of the
* species data. In other words while "phase" must
* point to an XML phase object, it must have
* sibling nodes "speciesData" that describe
* the species in the phase.
* param id ID of the phase. If nonnull, a check is done
* to see if phaseNode is pointing to the phase
* with the correct id.
*
* This routine initializes the lengths in the current object and
* then calls the parent routine.
*/
void VPStandardStateTP::initThermoXML(XML_Node& phaseNode, std::string id) {
VPStandardStateTP::initLengths();
//m_VPSS_ptr->initThermo();
for (int k = 0; k < m_kk; k++) {
PDSS *kPDSS = m_PDSS_storage[k];
AssertTrace(kPDSS != 0);
if (kPDSS) {
kPDSS->initThermoXML(phaseNode, id);
}
}
m_VPSS_ptr->initThermoXML(phaseNode, id);
ThermoPhase::initThermoXML(phaseNode, id);
}
/*!
* 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;
if (m_useTmpRefStateStorage) {
std::copy(m_g0_RT.begin(), m_g0_RT.end(), g);
scale(g, g+m_kk, g, _rt);
} else {
for (size_t k = 0; k < m_kk; k++) {
PDSS* kPDSS = m_PDSS_ptrs[k];
kPDSS->setState_TP(m_tlast, m_plast);
double h0_RT = kPDSS->enthalpy_RT_ref();
double s0_R = kPDSS->entropy_R_ref();
g[k] = _rt * (h0_RT - s0_R);
}
}
}
void VPSSMgr_Water_ConstVol::_updateRefStateThermo() const {
m_p0 = m_waterSS->pref_safe(m_tlast);
m_spthermo->update(m_tlast, &m_cp0_R[0], &m_h0_RT[0], &m_s0_R[0]);
for (int k = 0; k < m_kk; k++) {
m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];
PDSS *kPDSS = m_vptp_ptr->providePDSS(k);
kPDSS->setTemperature(m_tlast);
}
doublereal RT = GasConstant * m_tlast;
m_waterSS->setState_TP(m_tlast, m_p0);
m_h0_RT[0] = (m_waterSS->enthalpy_mole())/ RT;
m_s0_R[0] = (m_waterSS->entropy_mole()) / GasConstant;
m_cp0_R[0] = (m_waterSS->cp_mole()) / GasConstant;
m_g0_RT[0] = (m_hss_RT[0] - m_sss_R[0]);
m_V0[0] = m_vptp_ptr->molecularWeight(0) / (m_waterSS->density());
m_waterSS->setState_TP(m_tlast, m_plast);
}
void VPSSMgr_Water_HKFT::_updateRefStateThermo() const
{
m_p0 = m_waterSS->pref_safe(m_tlast);
m_waterSS->setState_TP(m_tlast, m_p0);
m_h0_RT[0] = (m_waterSS->enthalpy_mole()) / (GasConstant * m_tlast);
m_s0_R[0] = (m_waterSS->entropy_mole()) / GasConstant;
m_cp0_R[0] = (m_waterSS->cp_mole()) / GasConstant;
m_g0_RT[0] = (m_hss_RT[0] - m_sss_R[0]);
m_V0[0] = (m_waterSS->density()) / m_vptp_ptr->molecularWeight(0);
PDSS* ps;
for (size_t k = 1; k < m_kk; k++) {
ps = m_vptp_ptr->providePDSS(k);
ps->setState_TP(m_tlast, m_p0);
m_cp0_R[k] = ps->cp_R();
m_s0_R[k] = ps->entropy_mole() / GasConstant;
m_g0_RT[k] = ps->gibbs_RT();
m_h0_RT[k] = m_g0_RT[k] + m_s0_R[k];
m_V0[k] = ps->molarVolume();
}
m_waterSS->setState_TP(m_tlast, m_plast);
for (size_t k = 1; k < m_kk; k++) {
ps = m_vptp_ptr->providePDSS(k);
ps->setState_TP(m_tlast, m_plast);
}
}
void VPSSMgr_Water_ConstVol::_updateStandardStateThermo() {
doublereal RT = GasConstant * m_tlast;
doublereal del_pRT = (m_plast - OneAtm) / (RT);
for (int k = 1; k < m_kk; k++) {
m_hss_RT[k] = m_h0_RT[k] + del_pRT * m_Vss[k];
m_cpss_R[k] = m_cp0_R[k];
m_sss_R[k] = m_s0_R[k];
m_gss_RT[k] = m_hss_RT[k] - m_sss_R[k];
// m_Vss[k] constant
PDSS *kPDSS = m_vptp_ptr->providePDSS(k);
kPDSS->setState_TP(m_tlast, m_plast);
}
// Do the water
m_waterSS->setState_TP(m_tlast, m_plast);
m_hss_RT[0] = (m_waterSS->enthalpy_mole())/ RT;
m_sss_R[0] = (m_waterSS->entropy_mole()) / GasConstant;
m_cpss_R[0] = (m_waterSS->cp_mole()) / GasConstant;
m_gss_RT[0] = (m_hss_RT[0] - m_sss_R[0]);
m_Vss[0] = (m_vptp_ptr->molecularWeight(0) / m_waterSS->density());
}
void VPSSMgr_General::_updateStandardStateThermo()
{
for (size_t k = 0; k < m_kk; k++) {
PDSS* kPDSS = m_PDSS_ptrs[k];
kPDSS->setState_TP(m_tlast, m_plast);
m_hss_RT[k] = kPDSS->enthalpy_RT();
m_sss_R[k] = kPDSS->entropy_R();
m_gss_RT[k] = m_hss_RT[k] - m_sss_R[k];
m_cpss_R[k] = kPDSS->cp_R();
m_Vss[k] = kPDSS->molarVolume();
}
}
//====================================================================================================================
void VPSSMgr_General::_updateRefStateThermo() const
{
if (m_useTmpRefStateStorage) {
for (size_t k = 0; k < m_kk; k++) {
PDSS* kPDSS = m_PDSS_ptrs[k];
kPDSS->setState_TP(m_tlast, m_plast);
m_h0_RT[k] = kPDSS->enthalpy_RT_ref();
m_s0_R[k] = kPDSS->entropy_R_ref();
m_g0_RT[k] = m_h0_RT[k] - m_s0_R[k];
m_cp0_R[k] = kPDSS->cp_R_ref();
m_V0[k] = kPDSS->molarVolume_ref();
}
}
}
void VPSSMgr_Water_HKFT::_updateStandardStateThermo()
{
// Do the water
m_waterSS->setState_TP(m_tlast, m_plast);
m_hss_RT[0] = (m_waterSS->enthalpy_mole()) / (GasConstant * m_tlast);
m_sss_R[0] = (m_waterSS->entropy_mole()) / GasConstant;
m_cpss_R[0] = (m_waterSS->cp_mole()) / GasConstant;
m_gss_RT[0] = (m_hss_RT[0] - m_sss_R[0]);
m_Vss[0] = (m_vptp_ptr->molecularWeight(0)) / (m_waterSS->density());
for (size_t k = 1; k < m_kk; k++) {
PDSS* ps = m_vptp_ptr->providePDSS(k);
ps->setState_TP(m_tlast, m_plast);
m_cpss_R[k] = ps->cp_R();
m_sss_R[k] = ps->entropy_R();
m_gss_RT[k] = ps->gibbs_RT();
m_hss_RT[k] = m_gss_RT[k] + m_sss_R[k];
m_Vss[k] = ps->molarVolume();
}
}
/*
* operator=()
*
* Note this stuff will not work until the underlying phase
* has a working assignment operator
*/
VPStandardStateTP&
VPStandardStateTP::operator=(const VPStandardStateTP &b) {
if (&b != this) {
/*
* Mostly, this is a passthrough to the underlying
* assignment operator for the ThermoPhase parent object.
*/
ThermoPhase::operator=(b);
/*
* However, we have to handle data that we own.
*/
m_Pcurrent = b.m_Pcurrent;
m_Tlast_ss = b.m_Tlast_ss;
m_Plast_ss = b.m_Plast_ss;
m_P0 = b.m_P0;
/*
* Duplicate the pdss objects
*/
if (m_PDSS_storage.size() > 0) {
for (int k = 0; k < (int) m_PDSS_storage.size(); k++) {
delete(m_PDSS_storage[k]);
}
}
m_PDSS_storage.resize(m_kk);
for (int k = 0; k < m_kk; k++) {
PDSS *ptmp = b.m_PDSS_storage[k];
m_PDSS_storage[k] = ptmp->duplMyselfAsPDSS();
}
/*
* Duplicate the VPSS Manager object that conducts the calculations
*/
if (m_VPSS_ptr) {
delete m_VPSS_ptr;
m_VPSS_ptr = 0;
}
m_VPSS_ptr = (b.m_VPSS_ptr)->duplMyselfAsVPSSMgr();
/*
* The VPSSMgr object contains shallow pointers. Whenever you have shallow
* pointers, they have to be fixed up to point to the correct objects refering
* back to this ThermoPhase's properties.
*/
m_VPSS_ptr->initAllPtrs(this, m_spthermo);
/*
* The PDSS objects contains shallow pointers. Whenever you have shallow
* pointers, they have to be fixed up to point to the correct objects refering
* back to this ThermoPhase's properties. This function also sets m_VPSS_ptr
* so it occurs after m_VPSS_ptr is set.
*/
for (int k = 0; k < m_kk; k++) {
PDSS *ptmp = m_PDSS_storage[k];
ptmp->initAllPtrs(this, m_VPSS_ptr, m_spthermo);
}
/*
* Ok, the VPSSMgr object is ready for business.
* We need to resync the temperature and the pressure of the new standard states
* with what is storred in this object.
*/
m_VPSS_ptr->setState_TP(m_Tlast_ss, m_Plast_ss);
}
return *this;
}
PDSS_enumType VPSSMgr_General::reportPDSSType(int k) const
{
PDSS* kPDSS = m_PDSS_ptrs[k];
return kPDSS->reportPDSSType();
}
