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

Remove unnecessary newlines in function signatures

Browse source
This commit is contained in:
Ray Speth 2015-07-28 19:05:03 -04:00
parent d086be8d3d
commit f219b49e63
25 changed files with 119 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/thermo/FixedChemPotSSTP.cpp
View file

@ -118,8 +118,7 @@ FixedChemPotSSTP::FixedChemPotSSTP(const FixedChemPotSSTP& right)
*this = right;
}
FixedChemPotSSTP&
FixedChemPotSSTP::operator=(const FixedChemPotSSTP& right)
FixedChemPotSSTP& FixedChemPotSSTP::operator=(const FixedChemPotSSTP& right)
{
if (&right != this) {
SingleSpeciesTP::operator=(right);

3
src/thermo/GeneralSpeciesThermo.cpp
View file

@ -73,8 +73,7 @@ GeneralSpeciesThermo::operator=(const GeneralSpeciesThermo& b)
return *this;
}
SpeciesThermo*
GeneralSpeciesThermo::duplMyselfAsSpeciesThermo() const
SpeciesThermo* GeneralSpeciesThermo::duplMyselfAsSpeciesThermo() const
{
return new GeneralSpeciesThermo(*this);
}

3
src/thermo/IonsFromNeutralVPSSTP.cpp
View file

@ -152,8 +152,7 @@ IonsFromNeutralVPSSTP::~IonsFromNeutralVPSSTP()
}
}
ThermoPhase*
IonsFromNeutralVPSSTP::duplMyselfAsThermoPhase() const
ThermoPhase* IonsFromNeutralVPSSTP::duplMyselfAsThermoPhase() const
{
return new IonsFromNeutralVPSSTP(*this);
}

3
src/thermo/LatticeSolidPhase.cpp
View file

@ -33,8 +33,7 @@ LatticeSolidPhase::LatticeSolidPhase(const LatticeSolidPhase& right) :
*this = right;
}
LatticeSolidPhase&
LatticeSolidPhase::operator=(const LatticeSolidPhase& right)
LatticeSolidPhase& LatticeSolidPhase::operator=(const LatticeSolidPhase& right)
{
if (&right != this) {
ThermoPhase::operator=(right);

3
src/thermo/MargulesVPSSTP.cpp
View file

@ -76,8 +76,7 @@ MargulesVPSSTP& MargulesVPSSTP::operator=(const MargulesVPSSTP& b)
return *this;
}
ThermoPhase*
MargulesVPSSTP::duplMyselfAsThermoPhase() const
ThermoPhase* MargulesVPSSTP::duplMyselfAsThermoPhase() const
{
return new MargulesVPSSTP(*this);
}

3
src/thermo/MetalSHEelectrons.cpp
View file

@ -82,8 +82,7 @@ MetalSHEelectrons::~MetalSHEelectrons()
delete xdef_;
}
MetalSHEelectrons&
MetalSHEelectrons::operator=(const MetalSHEelectrons& right)
MetalSHEelectrons& MetalSHEelectrons::operator=(const MetalSHEelectrons& right)
{
if (&right != this) {
SingleSpeciesTP::operator=(right);

3
src/thermo/MixedSolventElectrolyte.cpp
View file

@ -80,8 +80,7 @@ MixedSolventElectrolyte::operator=(const MixedSolventElectrolyte& b)
return *this;
}
ThermoPhase*
MixedSolventElectrolyte::duplMyselfAsThermoPhase() const
ThermoPhase* MixedSolventElectrolyte::duplMyselfAsThermoPhase() const
{
return new MixedSolventElectrolyte(*this);
}

3
src/thermo/MixtureFugacityTP.cpp
View file

@ -38,8 +38,7 @@ MixtureFugacityTP::MixtureFugacityTP(const MixtureFugacityTP& b) :
MixtureFugacityTP::operator=(b);
}
MixtureFugacityTP&
MixtureFugacityTP::operator=(const MixtureFugacityTP& b)
MixtureFugacityTP& MixtureFugacityTP::operator=(const MixtureFugacityTP& b)
{
if (&b != this) {
/*

3
src/thermo/MolarityIonicVPSSTP.cpp
View file

@ -83,8 +83,7 @@ MolarityIonicVPSSTP& MolarityIonicVPSSTP::operator=(const MolarityIonicVPSSTP& b
return *this;
}
ThermoPhase*
MolarityIonicVPSSTP::duplMyselfAsThermoPhase() const
ThermoPhase* MolarityIonicVPSSTP::duplMyselfAsThermoPhase() const
{
return new MolarityIonicVPSSTP(*this);
}

3
src/thermo/Mu0Poly.cpp
View file

@ -27,8 +27,7 @@ Mu0Poly::Mu0Poly(double tlow, double thigh, double pref, const double* coeffs) :
processCoeffs(coeffs);
}
SpeciesThermoInterpType*
Mu0Poly::duplMyselfAsSpeciesThermoInterpType() const
SpeciesThermoInterpType* Mu0Poly::duplMyselfAsSpeciesThermoInterpType() const
{
return new Mu0Poly(*this);
}

27
src/thermo/PDSS_ConstVol.cpp
View file

@ -144,57 +144,48 @@ void PDSS_ConstVol::initThermo()
m_Vss_ptr[m_spindex] = m_constMolarVolume;
}
doublereal
PDSS_ConstVol::enthalpy_RT() const
doublereal PDSS_ConstVol::enthalpy_RT() const
{
return m_hss_RT_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::intEnergy_mole() const
doublereal PDSS_ConstVol::intEnergy_mole() const
{
doublereal pV = (m_pres * m_Vss_ptr[m_spindex]);
return m_h0_RT_ptr[m_spindex] * GasConstant * m_temp - pV;
}
doublereal
PDSS_ConstVol::entropy_R() const
doublereal PDSS_ConstVol::entropy_R() const
{
return m_sss_R_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::gibbs_RT() const
doublereal PDSS_ConstVol::gibbs_RT() const
{
return m_gss_RT_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::cp_R() const
doublereal PDSS_ConstVol::cp_R() const
{
return m_cpss_R_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::cv_mole() const
doublereal PDSS_ConstVol::cv_mole() const
{
return (cp_mole() - m_V0_ptr[m_spindex]);
}
doublereal
PDSS_ConstVol::molarVolume() const
doublereal PDSS_ConstVol::molarVolume() const
{
return m_Vss_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::density() const
doublereal PDSS_ConstVol::density() const
{
return m_mw / m_Vss_ptr[m_spindex];
}
doublereal
PDSS_ConstVol::gibbs_RT_ref() const
doublereal PDSS_ConstVol::gibbs_RT_ref() const
{
return m_g0_RT_ptr[m_spindex];
}

18
src/thermo/PDSS_HKFT.cpp
View file

@ -367,14 +367,12 @@ doublereal PDSS_HKFT::molarVolume() const
return molVol_calgmolPascal * 4.184 * 1.0E3;
}
doublereal
PDSS_HKFT::density() const
doublereal PDSS_HKFT::density() const
{
return m_mw / molarVolume();
}
doublereal
PDSS_HKFT::gibbs_RT_ref() const
doublereal PDSS_HKFT::gibbs_RT_ref() const
{
doublereal m_psave = m_pres;
m_pres = m_waterSS->pref_safe(m_temp);
@ -383,8 +381,7 @@ PDSS_HKFT::gibbs_RT_ref() const
return ee;
}
doublereal
PDSS_HKFT::enthalpy_RT_ref() const
doublereal PDSS_HKFT::enthalpy_RT_ref() const
{
doublereal m_psave = m_pres;
m_pres = m_waterSS->pref_safe(m_temp);
@ -393,8 +390,7 @@ PDSS_HKFT::enthalpy_RT_ref() const
return hh;
}
doublereal
PDSS_HKFT::entropy_R_ref() const
doublereal PDSS_HKFT::entropy_R_ref() const
{
doublereal m_psave = m_pres;
m_pres = m_waterSS->pref_safe(m_temp);
@ -403,8 +399,7 @@ PDSS_HKFT::entropy_R_ref() const
return ee;
}
doublereal
PDSS_HKFT::cp_R_ref() const
doublereal PDSS_HKFT::cp_R_ref() const
{
doublereal m_psave = m_pres;
m_pres = m_waterSS->pref_safe(m_temp);
@ -413,8 +408,7 @@ PDSS_HKFT::cp_R_ref() const
return ee;
}
doublereal
PDSS_HKFT::molarVolume_ref() const
doublereal PDSS_HKFT::molarVolume_ref() const
{
doublereal m_psave = m_pres;
m_pres = m_waterSS->pref_safe(m_temp);

30
src/thermo/PDSS_IdealGas.cpp
View file

@ -110,57 +110,47 @@ void PDSS_IdealGas::initThermo()
m_maxTemp = m_spthermo->maxTemp(m_spindex);
}
doublereal
PDSS_IdealGas::enthalpy_RT() const
doublereal PDSS_IdealGas::enthalpy_RT() const
{
return m_h0_RT_ptr[m_spindex];
}
doublereal
PDSS_IdealGas::intEnergy_mole() const
doublereal PDSS_IdealGas::intEnergy_mole() const
{
return (m_h0_RT_ptr[m_spindex] - 1.0) * GasConstant * m_temp;
}
doublereal
PDSS_IdealGas::entropy_R() const
doublereal PDSS_IdealGas::entropy_R() const
{
return m_s0_R_ptr[m_spindex] - log(m_pres/m_p0);
}
doublereal
PDSS_IdealGas::gibbs_RT() const
doublereal PDSS_IdealGas::gibbs_RT() const
{
return m_g0_RT_ptr[m_spindex] + log(m_pres/m_p0);
}
doublereal
PDSS_IdealGas::cp_R() const
doublereal PDSS_IdealGas::cp_R() const
{
return m_cp0_R_ptr[m_spindex];
}
doublereal
PDSS_IdealGas::molarVolume() const
doublereal PDSS_IdealGas::molarVolume() const
{
return GasConstant * m_temp / m_pres;
}
doublereal
PDSS_IdealGas::density() const
doublereal PDSS_IdealGas::density() const
{
return m_pres * m_mw / (GasConstant * m_temp);
}
doublereal
PDSS_IdealGas::cv_mole() const
doublereal PDSS_IdealGas::cv_mole() const
{
return cp_mole() - GasConstant;
}
doublereal
PDSS_IdealGas::gibbs_RT_ref() const
doublereal PDSS_IdealGas::gibbs_RT_ref() const
{
return m_g0_RT_ptr[m_spindex];
}
@ -185,7 +175,7 @@ doublereal PDSS_IdealGas::molarVolume_ref() const
return GasConstant * m_temp / m_p0;
}
doublereal PDSS_IdealGas::pressure() const
doublereal PDSS_IdealGas::pressure() const
{
throw CanteraError("PDSS_IdealGas::pressure()", "unimplemented");
}

26
src/thermo/PDSS_IonsFromNeutral.cpp
View file

@ -206,8 +206,7 @@ void PDSS_IonsFromNeutral::initThermo()
m_maxTemp = m_spthermo->maxTemp(m_spindex);
}
doublereal
PDSS_IonsFromNeutral::enthalpy_RT() const
doublereal PDSS_IonsFromNeutral::enthalpy_RT() const
{
neutralMoleculePhase_->getEnthalpy_RT(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -218,14 +217,12 @@ PDSS_IonsFromNeutral::enthalpy_RT() const
return val;
}
doublereal
PDSS_IonsFromNeutral::intEnergy_mole() const
doublereal PDSS_IonsFromNeutral::intEnergy_mole() const
{
return (m_h0_RT_ptr[m_spindex] - 1.0) * GasConstant * m_temp;
}
doublereal
PDSS_IonsFromNeutral::entropy_R() const
doublereal PDSS_IonsFromNeutral::entropy_R() const
{
neutralMoleculePhase_->getEntropy_R(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -239,8 +236,7 @@ PDSS_IonsFromNeutral::entropy_R() const
return val;
}
doublereal
PDSS_IonsFromNeutral::gibbs_RT() const
doublereal PDSS_IonsFromNeutral::gibbs_RT() const
{
neutralMoleculePhase_->getGibbs_RT(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -254,8 +250,7 @@ PDSS_IonsFromNeutral::gibbs_RT() const
return val;
}
doublereal
PDSS_IonsFromNeutral::cp_R() const
doublereal PDSS_IonsFromNeutral::cp_R() const
{
neutralMoleculePhase_->getCp_R(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -266,8 +261,7 @@ PDSS_IonsFromNeutral::cp_R() const
return val;
}
doublereal
PDSS_IonsFromNeutral::molarVolume() const
doublereal PDSS_IonsFromNeutral::molarVolume() const
{
neutralMoleculePhase_->getStandardVolumes(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -278,14 +272,12 @@ PDSS_IonsFromNeutral::molarVolume() const
return val;
}
doublereal
PDSS_IonsFromNeutral::density() const
doublereal PDSS_IonsFromNeutral::density() const
{
return (m_pres * m_mw / (GasConstant * m_temp));
}
doublereal
PDSS_IonsFromNeutral::gibbs_RT_ref() const
doublereal PDSS_IonsFromNeutral::gibbs_RT_ref() const
{
neutralMoleculePhase_->getGibbs_RT_ref(DATA_PTR(tmpNM));
doublereal val = 0.0;
@ -366,7 +358,7 @@ void PDSS_IonsFromNeutral::setState_TP(doublereal temp, doublereal pres)
m_temp = temp;
}
void PDSS_IonsFromNeutral::setState_TR(doublereal temp, doublereal rho)
void PDSS_IonsFromNeutral::setState_TR(doublereal temp, doublereal rho)
{
}

27
src/thermo/PDSS_SSVol.cpp
View file

@ -173,57 +173,48 @@ void PDSS_SSVol::initThermo()
m_Vss_ptr[m_spindex] = m_constMolarVolume;
}
doublereal
PDSS_SSVol::enthalpy_RT() const
doublereal PDSS_SSVol::enthalpy_RT() const
{
return m_hss_RT_ptr[m_spindex];
}
doublereal
PDSS_SSVol::intEnergy_mole() const
doublereal PDSS_SSVol::intEnergy_mole() const
{
doublereal pV = m_pres * m_Vss_ptr[m_spindex];
return m_h0_RT_ptr[m_spindex] * GasConstant * m_temp - pV;
}
doublereal
PDSS_SSVol::entropy_R() const
doublereal PDSS_SSVol::entropy_R() const
{
return m_sss_R_ptr[m_spindex];
}
doublereal
PDSS_SSVol::gibbs_RT() const
doublereal PDSS_SSVol::gibbs_RT() const
{
return m_gss_RT_ptr[m_spindex];
}
doublereal
PDSS_SSVol::cp_R() const
doublereal PDSS_SSVol::cp_R() const
{
return m_cpss_R_ptr[m_spindex];
}
doublereal
PDSS_SSVol::cv_mole() const
doublereal PDSS_SSVol::cv_mole() const
{
return (cp_mole() - m_V0_ptr[m_spindex]);
}
doublereal
PDSS_SSVol::molarVolume() const
doublereal PDSS_SSVol::molarVolume() const
{
return m_Vss_ptr[m_spindex];
}
doublereal
PDSS_SSVol::density() const
doublereal PDSS_SSVol::density() const
{
return m_mw / m_Vss_ptr[m_spindex];
}
doublereal
PDSS_SSVol::gibbs_RT_ref() const
doublereal PDSS_SSVol::gibbs_RT_ref() const
{
return m_g0_RT_ptr[m_spindex];
}

3
src/thermo/PhaseCombo_Interaction.cpp
View file

@ -75,8 +75,7 @@ PhaseCombo_Interaction& PhaseCombo_Interaction::operator=(const PhaseCombo_Inter
return *this;
}
ThermoPhase*
PhaseCombo_Interaction::duplMyselfAsThermoPhase() const
ThermoPhase* PhaseCombo_Interaction::duplMyselfAsThermoPhase() const
{
return new PhaseCombo_Interaction(*this);
}

3
src/thermo/SpeciesThermoInterpType.cpp
View file

@ -74,8 +74,7 @@ STITbyPDSS::STITbyPDSS(const STITbyPDSS& b) :
{
}
SpeciesThermoInterpType*
STITbyPDSS::duplMyselfAsSpeciesThermoInterpType() const
SpeciesThermoInterpType* STITbyPDSS::duplMyselfAsSpeciesThermoInterpType() const
{
return new STITbyPDSS(*this);
}

51
src/thermo/VPSSMgr.cpp
View file

@ -57,8 +57,7 @@ VPSSMgr::VPSSMgr(const VPSSMgr& right) :
*this = right;
}
VPSSMgr&
VPSSMgr::operator=(const VPSSMgr& right)
VPSSMgr& VPSSMgr::operator=(const VPSSMgr& right)
{
if (&right == this) {
return *this;
@ -141,8 +140,7 @@ void VPSSMgr::initAllPtrs(VPStandardStateTP* vp_ptr,
// Standard States
void
VPSSMgr::getStandardChemPotentials(doublereal* mu) const
void VPSSMgr::getStandardChemPotentials(doublereal* mu) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_gss_RT.begin(), m_gss_RT.end(), mu);
@ -152,8 +150,7 @@ VPSSMgr::getStandardChemPotentials(doublereal* mu) const
}
}
void
VPSSMgr::getGibbs_RT(doublereal* grt) const
void VPSSMgr::getGibbs_RT(doublereal* grt) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_gss_RT.begin(), m_gss_RT.end(), grt);
@ -162,8 +159,7 @@ VPSSMgr::getGibbs_RT(doublereal* grt) const
}
}
void
VPSSMgr::getEnthalpy_RT(doublereal* hrt) const
void VPSSMgr::getEnthalpy_RT(doublereal* hrt) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_hss_RT.begin(), m_hss_RT.end(), hrt);
@ -172,8 +168,7 @@ VPSSMgr::getEnthalpy_RT(doublereal* hrt) const
}
}
void
VPSSMgr::getEntropy_R(doublereal* sr) const
void VPSSMgr::getEntropy_R(doublereal* sr) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_sss_R.begin(), m_sss_R.end(), sr);
@ -182,8 +177,7 @@ VPSSMgr::getEntropy_R(doublereal* sr) const
}
}
void
VPSSMgr::getIntEnergy_RT(doublereal* urt) const
void VPSSMgr::getIntEnergy_RT(doublereal* urt) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_hss_RT.begin(), m_hss_RT.end(), urt);
@ -195,8 +189,7 @@ VPSSMgr::getIntEnergy_RT(doublereal* urt) const
}
}
void
VPSSMgr::getCp_R(doublereal* cpr) const
void VPSSMgr::getCp_R(doublereal* cpr) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_cpss_R.begin(), m_cpss_R.end(), cpr);
@ -205,8 +198,7 @@ VPSSMgr::getCp_R(doublereal* cpr) const
}
}
void
VPSSMgr::getStandardVolumes(doublereal* vol) const
void VPSSMgr::getStandardVolumes(doublereal* vol) const
{
if (m_useTmpStandardStateStorage) {
std::copy(m_Vss.begin(), m_Vss.end(), vol);
@ -214,8 +206,7 @@ VPSSMgr::getStandardVolumes(doublereal* vol) const
throw NotImplementedError("VPSSMgr::getStandardVolumes");
}
}
const vector_fp&
VPSSMgr::getStandardVolumes() const
const vector_fp& VPSSMgr::getStandardVolumes() const
{
if (!m_useTmpStandardStateStorage) {
throw NotImplementedError("VPSSMgr::getStandardVolumes");
@ -224,8 +215,7 @@ VPSSMgr::getStandardVolumes() const
}
/*****************************************************************/
void
VPSSMgr::getEnthalpy_RT_ref(doublereal* hrt) const
void VPSSMgr::getEnthalpy_RT_ref(doublereal* hrt) const
{
if (m_useTmpRefStateStorage) {
std::copy(m_h0_RT.begin(), m_h0_RT.end(), hrt);
@ -234,8 +224,7 @@ VPSSMgr::getEnthalpy_RT_ref(doublereal* hrt) const
}
}
void
VPSSMgr::getGibbs_RT_ref(doublereal* grt) const
void VPSSMgr::getGibbs_RT_ref(doublereal* grt) const
{
if (m_useTmpRefStateStorage) {
std::copy(m_g0_RT.begin(), m_g0_RT.end(), grt);
@ -244,8 +233,7 @@ VPSSMgr::getGibbs_RT_ref(doublereal* grt) const
}
}
void
VPSSMgr::getGibbs_ref(doublereal* g) const
void VPSSMgr::getGibbs_ref(doublereal* g) const
{
if (m_useTmpRefStateStorage) {
std::copy(m_g0_RT.begin(), m_g0_RT.end(), g);
@ -255,8 +243,7 @@ VPSSMgr::getGibbs_ref(doublereal* g) const
}
}
void
VPSSMgr::getEntropy_R_ref(doublereal* sr) const
void VPSSMgr::getEntropy_R_ref(doublereal* sr) const
{
if (m_useTmpRefStateStorage) {
std::copy(m_s0_R.begin(), m_s0_R.end(), sr);
@ -265,8 +252,7 @@ VPSSMgr::getEntropy_R_ref(doublereal* sr) const
}
}
void
VPSSMgr::getCp_R_ref(doublereal* cpr) const
void VPSSMgr::getCp_R_ref(doublereal* cpr) const
{
if (m_useTmpRefStateStorage) {
std::copy(m_cp0_R.begin(), m_cp0_R.end(), cpr);
@ -275,8 +261,7 @@ VPSSMgr::getCp_R_ref(doublereal* cpr) const
}
}
void
VPSSMgr::getStandardVolumes_ref(doublereal* vol) const
void VPSSMgr::getStandardVolumes_ref(doublereal* vol) const
{
getStandardVolumes(vol);
}
@ -345,14 +330,12 @@ void VPSSMgr::_updateRefStateThermo() const
/*****************************************************************/
void
VPSSMgr::initThermo()
void VPSSMgr::initThermo()
{
initLengths();
}
void
VPSSMgr::initLengths()
void VPSSMgr::initLengths()
{
m_kk = m_vptp_ptr->nSpecies();
m_h0_RT.resize(m_kk, 0.0);

11
src/thermo/VPSSMgrFactory.cpp
View file

@ -200,10 +200,9 @@ VPSSMgrFactory::VPSSMgr_StringConversion(const std::string& ssModel) const
return type;
}
VPSSMgr*
VPSSMgrFactory::newVPSSMgr(VPStandardStateTP* vp_ptr,
XML_Node* phaseNode_ptr,
std::vector<XML_Node*> & spDataNodeList)
VPSSMgr* VPSSMgrFactory::newVPSSMgr(VPStandardStateTP* vp_ptr,
XML_Node* phaseNode_ptr,
std::vector<XML_Node*> & spDataNodeList)
{
std::string ssManager;
@ -285,8 +284,8 @@ VPSSMgrFactory::newVPSSMgr(VPStandardStateTP* vp_ptr,
// I don't think this is currently used. However, this is a virtual
// function where additional capabilities may be added.
VPSSMgr*
VPSSMgrFactory::newVPSSMgr(VPSSMgr_enumType type, VPStandardStateTP* vp_ptr)
VPSSMgr* VPSSMgrFactory::newVPSSMgr(VPSSMgr_enumType type,
VPStandardStateTP* vp_ptr)
{
SpeciesThermo& spthermoRef = vp_ptr->speciesThermo();
switch (type) {

8
src/thermo/VPSSMgr_ConstVol.cpp
View file

@ -96,8 +96,7 @@ void VPSSMgr_ConstVol::initThermo()
VPSSMgr::initThermo();
}
void
VPSSMgr_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id)
void VPSSMgr_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id)
{
VPSSMgr::initThermoXML(phaseNode, id);
@ -125,9 +124,8 @@ VPSSMgr_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id)
}
}
PDSS*
VPSSMgr_ConstVol::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
PDSS* VPSSMgr_ConstVol::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
{
const XML_Node* ss = speciesNode.findByName("standardState");
if (!ss) {

13
src/thermo/VPSSMgr_General.cpp
View file

@ -134,15 +134,13 @@ void VPSSMgr_General::getGibbs_ref(doublereal* g) const
}
}
void
VPSSMgr_General::initThermoXML(XML_Node& phaseNode, const std::string& id)
void VPSSMgr_General::initThermoXML(XML_Node& phaseNode, const std::string& id)
{
VPSSMgr::initThermoXML(phaseNode, id);
}
PDSS*
VPSSMgr_General::returnPDSS_ptr(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr, bool& doST)
PDSS* VPSSMgr_General::returnPDSS_ptr(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr, bool& doST)
{
PDSS* kPDSS = 0;
doST = true;
@ -205,9 +203,8 @@ VPSSMgr_General::returnPDSS_ptr(size_t k, const XML_Node& speciesNode,
return kPDSS;
}
PDSS*
VPSSMgr_General::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
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);

8
src/thermo/VPSSMgr_IdealGas.cpp
View file

@ -80,15 +80,13 @@ void VPSSMgr_IdealGas::_updateStandardStateThermo()
}
}
void
VPSSMgr_IdealGas::initThermoXML(XML_Node& phaseNode, const std::string& id)
void VPSSMgr_IdealGas::initThermoXML(XML_Node& phaseNode, const std::string& id)
{
VPSSMgr::initThermoXML(phaseNode, id);
}
PDSS*
VPSSMgr_IdealGas::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
PDSS* VPSSMgr_IdealGas::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
{
const XML_Node* ss = speciesNode.findByName("standardState");
if (ss) {

35
src/thermo/VPSSMgr_Water_ConstVol.cpp
View file

@ -52,15 +52,13 @@ VPSSMgr_Water_ConstVol::operator=(const VPSSMgr_Water_ConstVol& b)
return *this;
}
VPSSMgr*
VPSSMgr_Water_ConstVol::duplMyselfAsVPSSMgr() const
VPSSMgr* VPSSMgr_Water_ConstVol::duplMyselfAsVPSSMgr() const
{
return new VPSSMgr_Water_ConstVol(*this);
}
void
VPSSMgr_Water_ConstVol::initAllPtrs(VPStandardStateTP* vp_ptr,
SpeciesThermo* sp_ptr)
void VPSSMgr_Water_ConstVol::initAllPtrs(VPStandardStateTP* vp_ptr,
SpeciesThermo* sp_ptr)
{
VPSSMgr::initAllPtrs(vp_ptr, sp_ptr);
m_waterSS = dynamic_cast<PDSS_Water*>(m_vptp_ptr->providePDSS(0));
@ -70,8 +68,7 @@ VPSSMgr_Water_ConstVol::initAllPtrs(VPStandardStateTP* vp_ptr,
}
}
void
VPSSMgr_Water_ConstVol::getEnthalpy_RT_ref(doublereal* hrt) const
void VPSSMgr_Water_ConstVol::getEnthalpy_RT_ref(doublereal* hrt) const
{
// Everything should be OK except for the water SS
m_p0 = m_waterSS->pref_safe(m_tlast);
@ -85,8 +82,7 @@ VPSSMgr_Water_ConstVol::getEnthalpy_RT_ref(doublereal* hrt) const
copy(m_h0_RT.begin(), m_h0_RT.end(), hrt);
}
void
VPSSMgr_Water_ConstVol::getGibbs_RT_ref(doublereal* grt) const
void VPSSMgr_Water_ConstVol::getGibbs_RT_ref(doublereal* grt) const
{
// Everything should be OK except for the water SS
m_p0 = m_waterSS->pref_safe(m_tlast);
@ -100,8 +96,7 @@ VPSSMgr_Water_ConstVol::getGibbs_RT_ref(doublereal* grt) const
copy(m_g0_RT.begin(), m_g0_RT.end(), grt);
}
void
VPSSMgr_Water_ConstVol::getGibbs_ref(doublereal* g) const
void VPSSMgr_Water_ConstVol::getGibbs_ref(doublereal* g) const
{
getGibbs_RT_ref(g);
for (size_t k = 0; k < m_kk; k++) {
@ -109,8 +104,7 @@ VPSSMgr_Water_ConstVol::getGibbs_ref(doublereal* g) const
}
}
void
VPSSMgr_Water_ConstVol::getEntropy_R_ref(doublereal* sr) const
void VPSSMgr_Water_ConstVol::getEntropy_R_ref(doublereal* sr) const
{
// Everything should be OK except for the water SS
m_p0 = m_waterSS->pref_safe(m_tlast);
@ -124,8 +118,7 @@ VPSSMgr_Water_ConstVol::getEntropy_R_ref(doublereal* sr) const
copy(m_s0_R.begin(), m_s0_R.end(), sr);
}
void
VPSSMgr_Water_ConstVol::getCp_R_ref(doublereal* cpr) const
void VPSSMgr_Water_ConstVol::getCp_R_ref(doublereal* cpr) const
{
// Everything should be OK except for the water SS
m_p0 = m_waterSS->pref_safe(m_tlast);
@ -139,8 +132,7 @@ VPSSMgr_Water_ConstVol::getCp_R_ref(doublereal* cpr) const
copy(m_cp0_R.begin(), m_cp0_R.end(), cpr);
}
void
VPSSMgr_Water_ConstVol::getStandardVolumes_ref(doublereal* vol) const
void VPSSMgr_Water_ConstVol::getStandardVolumes_ref(doublereal* vol) const
{
// Everything should be OK except for the water SS
m_p0 = m_waterSS->pref_safe(m_tlast);
@ -198,8 +190,8 @@ void VPSSMgr_Water_ConstVol::initThermo()
VPSSMgr::initThermo();
}
void
VPSSMgr_Water_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id)
void VPSSMgr_Water_ConstVol::initThermoXML(XML_Node& phaseNode,
const std::string& id)
{
VPSSMgr::initThermoXML(phaseNode, id);
@ -235,9 +227,8 @@ VPSSMgr_Water_ConstVol::initThermoXML(XML_Node& phaseNode, const std::string& id
}
}
PDSS*
VPSSMgr_Water_ConstVol::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
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

35
src/thermo/VPSSMgr_Water_HKFT.cpp
View file

@ -60,28 +60,24 @@ VPSSMgr_Water_HKFT::operator=(const VPSSMgr_Water_HKFT& b)
return *this;
}
VPSSMgr*
VPSSMgr_Water_HKFT::duplMyselfAsVPSSMgr() const
VPSSMgr* VPSSMgr_Water_HKFT::duplMyselfAsVPSSMgr() const
{
return new VPSSMgr_Water_HKFT(*this);
}
void
VPSSMgr_Water_HKFT::getEnthalpy_RT_ref(doublereal* hrt) const
void VPSSMgr_Water_HKFT::getEnthalpy_RT_ref(doublereal* hrt) const
{
updateRefStateThermo();
copy(m_h0_RT.begin(), m_h0_RT.end(), hrt);
}
void
VPSSMgr_Water_HKFT::getGibbs_RT_ref(doublereal* grt) const
void VPSSMgr_Water_HKFT::getGibbs_RT_ref(doublereal* grt) const
{
updateRefStateThermo();
copy(m_g0_RT.begin(), m_g0_RT.end(), grt);
}
void
VPSSMgr_Water_HKFT::getGibbs_ref(doublereal* g) const
void VPSSMgr_Water_HKFT::getGibbs_ref(doublereal* g) const
{
getGibbs_RT_ref(g);
for (size_t k = 0; k < m_kk; k++) {
@ -89,22 +85,19 @@ VPSSMgr_Water_HKFT::getGibbs_ref(doublereal* g) const
}
}
void
VPSSMgr_Water_HKFT::getEntropy_R_ref(doublereal* sr) const
void VPSSMgr_Water_HKFT::getEntropy_R_ref(doublereal* sr) const
{
updateRefStateThermo();
copy(m_s0_R.begin(), m_s0_R.end(), sr);
}
void
VPSSMgr_Water_HKFT::getCp_R_ref(doublereal* cpr) const
void VPSSMgr_Water_HKFT::getCp_R_ref(doublereal* cpr) const
{
updateRefStateThermo();
copy(m_cp0_R.begin(), m_cp0_R.end(), cpr);
}
void
VPSSMgr_Water_HKFT::getStandardVolumes_ref(doublereal* vol) const
void VPSSMgr_Water_HKFT::getStandardVolumes_ref(doublereal* vol) const
{
updateRefStateThermo();
copy(m_V0.begin(), m_V0.end(), vol);
@ -200,8 +193,8 @@ void VPSSMgr_Water_HKFT::initThermo()
}
void
VPSSMgr_Water_HKFT::initThermoXML(XML_Node& phaseNode, const std::string& id)
void VPSSMgr_Water_HKFT::initThermoXML(XML_Node& phaseNode,
const std::string& id)
{
VPSSMgr::initThermoXML(phaseNode, id);
@ -232,9 +225,8 @@ VPSSMgr_Water_HKFT::initThermoXML(XML_Node& phaseNode, const std::string& id)
}
}
PDSS*
VPSSMgr_Water_HKFT::createInstallPDSS(size_t k, const XML_Node& speciesNode,
const XML_Node* const phaseNode_ptr)
PDSS* VPSSMgr_Water_HKFT::createInstallPDSS(size_t k,
const XML_Node& speciesNode, const XML_Node* const phaseNode_ptr)
{
PDSS* kPDSS = 0;
@ -287,9 +279,8 @@ VPSSMgr_Water_HKFT::createInstallPDSS(size_t k, const XML_Node& speciesNode,
return kPDSS;
}
void
VPSSMgr_Water_HKFT::initAllPtrs(VPStandardStateTP* vp_ptr,
SpeciesThermo* sp_ptr)
void VPSSMgr_Water_HKFT::initAllPtrs(VPStandardStateTP* vp_ptr,
SpeciesThermo* sp_ptr)
{
VPSSMgr::initAllPtrs(vp_ptr, sp_ptr);
m_waterSS = dynamic_cast<PDSS_Water*>(m_vptp_ptr->providePDSS(0));

14
src/thermo/VPStandardStateTP.cpp
View file

@ -41,8 +41,7 @@ VPStandardStateTP::VPStandardStateTP(const VPStandardStateTP& b) :
VPStandardStateTP::operator=(b);
}
VPStandardStateTP&
VPStandardStateTP::operator=(const VPStandardStateTP& b)
VPStandardStateTP& VPStandardStateTP::operator=(const VPStandardStateTP& b)
{
if (&b != this) {
/*
@ -313,9 +312,8 @@ void VPStandardStateTP::setState_TP(doublereal t, doublereal pres)
void
VPStandardStateTP::createInstallPDSS(size_t k, const XML_Node& s,
const XML_Node* phaseNode_ptr)
void VPStandardStateTP::createInstallPDSS(size_t k, const XML_Node& s,
const XML_Node* phaseNode_ptr)
{
if (m_PDSS_storage.size() < k+1) {
m_PDSS_storage.resize(k+1,0);
@ -324,14 +322,12 @@ VPStandardStateTP::createInstallPDSS(size_t k, const XML_Node& s,
m_PDSS_storage[k] = m_VPSS_ptr->createInstallPDSS(k, s, phaseNode_ptr);
}
PDSS*
VPStandardStateTP::providePDSS(size_t k)
PDSS* VPStandardStateTP::providePDSS(size_t k)
{
return m_PDSS_storage[k];
}
const PDSS*
VPStandardStateTP::providePDSS(size_t k) const
const PDSS* VPStandardStateTP::providePDSS(size_t k) const
{
return m_PDSS_storage[k];
}