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

Remove unnecessary delimiter lines between functions

Browse source 
A single line of white space is sufficient and consistent. Also moved a couple
Doxygen strings out of source files.
This commit is contained in:
Ray Speth 2015-01-22 00:04:24 +00:00
parent b8a99b4b83
commit efb80dfe05
16 changed files with 70 additions and 120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
include/cantera/numerics/BandMatrix.h
View file

@ -154,6 +154,7 @@ public:
//! Return a reference to the pivot vector
vector_int& ipiv();
//! Multiply A*b and write result to \c prod.
virtual void mult(const doublereal* b, doublereal* prod) const;
virtual void leftMult(const doublereal* const b, doublereal* const prod) const;

33
include/cantera/numerics/ctlapack.h
View file

@ -222,7 +222,7 @@ extern "C" {
namespace Cantera
{
//====================================================================================================================
inline void ct_dgemv(ctlapack::storage_t storage,
ctlapack::transpose_t trans,
int m, int n, doublereal alpha, const doublereal* a, int lda,
@ -246,7 +246,6 @@ inline void ct_dgemv(ctlapack::storage_t storage,
#endif
}
//====================================================================================================================
inline void ct_dgbsv(int n, int kl, int ku, int nrhs,
doublereal* a, int lda, integer* ipiv, doublereal* b, int ldb,
int& info)
@ -355,7 +354,7 @@ inline void ct_dgetrs(ctlapack::transpose_t trans, size_t n,
#endif
info = f_info;
}
//====================================================================================================================
inline void ct_dgetri(int n, doublereal* a, int lda, integer* ipiv,
doublereal* work, int lwork, int& info)
{
@ -368,7 +367,7 @@ inline void ct_dscal(int n, doublereal da, doublereal* dx, int incx)
integer f_n = n, f_incx = incx;
_DSCAL_(&f_n, &da, dx, &f_incx);
}
//====================================================================================================================
inline void ct_dgeqrf(size_t m, size_t n, doublereal* a, size_t lda, doublereal* tau,
doublereal* work, size_t lwork, int& info)
{
@ -380,7 +379,7 @@ inline void ct_dgeqrf(size_t m, size_t n, doublereal* a, size_t lda, doublereal*
_DGEQRF_(&f_m, &f_n, a, &f_lda, tau, work, &f_lwork, &f_info);
info = f_info;
}
//====================================================================================================================
inline void ct_dormqr(ctlapack::side_t rlside, ctlapack::transpose_t trans, size_t m,
size_t n, size_t k, doublereal* a, size_t lda, doublereal* tau, doublereal* c, size_t ldc,
doublereal* work, size_t lwork, int& info)
@ -406,7 +405,7 @@ inline void ct_dormqr(ctlapack::side_t rlside, ctlapack::transpose_t trans, size
#endif
info = f_info;
}
//====================================================================================================================
inline void ct_dtrtrs(ctlapack::upperlower_t uplot, ctlapack::transpose_t trans, const char* diag,
size_t n, size_t nrhs, doublereal* a, size_t lda, doublereal* b, size_t ldb, int& info)
{
@ -433,7 +432,7 @@ inline void ct_dtrtrs(ctlapack::upperlower_t uplot, ctlapack::transpose_t trans,
#endif
info = f_info;
}
//====================================================================================================================
//!
/*!
* @param work Must be dimensioned equal to greater than 3N
@ -468,7 +467,6 @@ inline doublereal ct_dtrcon(const char* norm, ctlapack::upperlower_t uplot, con
info = f_info;
return rcond;
}
//====================================================================================================================
inline void ct_dpotrf(ctlapack::upperlower_t uplot, size_t n, doublereal* a, size_t lda, int& info)
{
@ -490,10 +488,7 @@ inline void ct_dpotrf(ctlapack::upperlower_t uplot, size_t n, doublereal* a, siz
info = f_info;
return;
}
//====================================================================================================================
//!
/*!
*/
inline void ct_dpotrs(ctlapack::upperlower_t uplot, size_t n, size_t nrhs, doublereal* a, size_t lda,
doublereal* b, size_t ldb, int& info)
{
@ -518,10 +513,6 @@ inline void ct_dpotrs(ctlapack::upperlower_t uplot, size_t n, size_t nrhs, doubl
return;
}
//====================================================================================================================
//!
/*!
*/
inline doublereal ct_dgecon(const char norm, size_t n, doublereal* a, size_t lda, doublereal anorm,
doublereal* work, int* iwork, int& info)
{
@ -548,10 +539,6 @@ inline doublereal ct_dgecon(const char norm, size_t n, doublereal* a, size_t lda
return rcond;
}
//====================================================================================================================
//!
/*!
*/
inline doublereal ct_dgbcon(const char norm, size_t n, size_t kl, size_t ku,
doublereal* a, size_t ldab, int* ipiv, doublereal anorm,
doublereal* work, int* iwork, int& info)
@ -581,10 +568,6 @@ inline doublereal ct_dgbcon(const char norm, size_t n, size_t kl, size_t ku,
return rcond;
}
//====================================================================================================================
//!
/*!
*/
inline doublereal ct_dlange(const char norm, size_t m, size_t n, doublereal* a, size_t lda,
doublereal* work)
{
@ -609,7 +592,7 @@ inline doublereal ct_dlange(const char norm, size_t m, size_t n, doublereal* a,
#endif
return anorm;
}
//====================================================================================================================
}
#endif

5
src/base/ctexceptions.cpp
View file

@ -74,7 +74,7 @@ std::string IndexError::getMessage() const
" outside valid range of 0 to " << (mmax_) << ".";
return ss.str();
}
//============================================================================================================
bool check_FENV_OverUnder_Flow() {
#ifdef HAVE_FENV_H
fexcept_t ff;
@ -85,12 +85,11 @@ bool check_FENV_OverUnder_Flow() {
#endif
return false;
};
//============================================================================================================
void clear_FENV() {
#ifdef HAVE_FENV_H
feclearexcept(FE_ALL_EXCEPT);
#endif
}
//============================================================================================================
} // namespace Cantera

8
src/base/stringUtils.cpp
View file

@ -240,7 +240,7 @@ doublereal fpValue(const std::string& val)
ss >> rval;
return rval;
}
//========================================================================================================================
doublereal fpValueCheck(const std::string& val)
{
std::string str = stripws(val);
@ -286,7 +286,7 @@ doublereal fpValueCheck(const std::string& val)
}
return fpValue(str);
}
//=====================================================================================================================
std::string logfileName(const std::string& infile)
{
warn_deprecated("logfileName", "To be removed after Cantera 2.2.");
@ -294,7 +294,7 @@ std::string logfileName(const std::string& infile)
logfile += ".log";
return logfile;
}
//====================================================================================================================
std::string wrapString(const std::string& s, const int len)
{
int count=0;
@ -313,7 +313,7 @@ std::string wrapString(const std::string& s, const int len)
}
return r;
}
//======================================================================================================================
std::string parseSpeciesName(const std::string& nameStr, std::string& phaseName)
{
std::string s = stripws(nameStr);

25
src/equil/vcs_phaseStability.cpp
View file

@ -13,22 +13,7 @@ using namespace Cantera;
namespace VCSnonideal
{
//====================================================================================================================
// Utility function that evaluates whether a phase can be popped into existence
/*
* A phase can be popped iff the stoichiometric coefficients for the
* component species, whose concentrations will be lowered during the
* process, are positive by at least a small degree.
*
* If one of the phase species is a zeroed component, then the phase can
* be popped if the component increases in mole number as the phase moles
* are increased.
*
* @param iphasePop id of the phase, which is currently zeroed,
*
* @return Returns true if the phase can come into existence
* and false otherwise.
*/
bool VCS_SOLVE::vcs_popPhasePossible(const size_t iphasePop) const
{
vcs_VolPhase* Vphase = m_VolPhaseList[iphasePop];
@ -122,7 +107,7 @@ bool VCS_SOLVE::vcs_popPhasePossible(const size_t iphasePop) const
}
return false;
}
//=====================================================================================================
int VCS_SOLVE::vcs_phasePopDeterminePossibleList()
{
int nfound = 0;
@ -240,7 +225,7 @@ int VCS_SOLVE::vcs_phasePopDeterminePossibleList()
return nfound;
}
//========================================================================================================
size_t VCS_SOLVE::vcs_popPhaseID(std::vector<size_t> & phasePopPhaseIDs)
{
size_t iphasePop = npos;
@ -516,7 +501,7 @@ int VCS_SOLVE::vcs_popPhaseRxnStepSizes(const size_t iphasePop)
return 0;
}
//====================================================================================================================
double VCS_SOLVE::vcs_phaseStabilityTest(const size_t iph)
{
/*
@ -824,5 +809,5 @@ double VCS_SOLVE::vcs_phaseStabilityTest(const size_t iph)
}
return funcPhaseStability;
}
//====================================================================================================================
}

5
src/kinetics/ReactionStoichMgr.cpp
View file

@ -47,7 +47,7 @@ ReactionStoichMgr& ReactionStoichMgr::operator=(const ReactionStoichMgr& right)
}
return *this;
}
//=========================================================================================================
void ReactionStoichMgr::add(size_t rxn, const std::vector<size_t>& reactants,
const std::vector<size_t>& products,
bool reversible)
@ -61,7 +61,7 @@ void ReactionStoichMgr::add(size_t rxn, const std::vector<size_t>& reactants,
m_irrevproducts.add(rxn, products);
}
}
//=========================================================================================================
// Add the reaction into the stoichiometric manager
void ReactionStoichMgr::add(size_t rxn, const ReactionData& r)
{
@ -183,7 +183,6 @@ void ReactionStoichMgr::add(size_t rxn, const ReactionData& r)
}
}
}
//=========================================================================================================
void ReactionStoichMgr::getCreationRates(size_t nsp, const doublereal* ropf,
const doublereal* ropr, doublereal* c)

18
src/numerics/BandMatrix.cpp
View file

@ -169,38 +169,32 @@ size_t BandMatrix::nRowsAndStruct(size_t* const iStruct) const
}
return m_n;
}
//====================================================================================================================
// Number of columns
size_t BandMatrix::nColumns() const
{
return m_n;
}
//====================================================================================================================
// Number of subdiagonals
size_t BandMatrix::nSubDiagonals() const
{
return m_kl;
}
//====================================================================================================================
// Number of superdiagonals
size_t BandMatrix::nSuperDiagonals() const
{
return m_ku;
}
//====================================================================================================================
size_t BandMatrix::ldim() const
{
return 2*m_kl + m_ku + 1;
}
//====================================================================================================================
vector_int& BandMatrix::ipiv()
{
return m_ipiv;
}
//====================================================================================================================
/*
* Multiply A*b and write result to \c prod.
*/
void BandMatrix::mult(const doublereal* b, doublereal* prod) const
{
int kl = static_cast<int>(m_kl);

2
src/numerics/NonlinearSolver.cpp
View file

@ -3160,7 +3160,7 @@ void NonlinearSolver::print_solnDelta_norm_contrib(const doublereal* const step_
printf("\t\t ");
writeline('-', 125);
}
//====================================================================================================================
//! This routine subtracts two numbers for one another
/*!
* This routine subtracts 2 numbers. If the difference is less

2
src/numerics/solveProb.cpp
View file

@ -701,7 +701,7 @@ void solveProb::print_header(int ioflag, int ifunc, doublereal time_scale,
"------------------------------------\n");
}
}
//================================================================================================
void solveProb::printIteration(int ioflag, doublereal damp, size_t label_d,
size_t label_t,
doublereal inv_t, doublereal t_real, int iter,

52
src/thermo/GibbsExcessVPSSTP.cpp
View file

@ -22,16 +22,16 @@ using namespace std;
namespace Cantera
{
//=========================================================================================================================
GibbsExcessVPSSTP::GibbsExcessVPSSTP()
{
}
//=========================================================================================================================
GibbsExcessVPSSTP::GibbsExcessVPSSTP(const GibbsExcessVPSSTP& b)
{
GibbsExcessVPSSTP::operator=(b);
}
//=========================================================================================================================
GibbsExcessVPSSTP& GibbsExcessVPSSTP::operator=(const GibbsExcessVPSSTP& b)
{
if (&b == this) {
@ -51,51 +51,50 @@ GibbsExcessVPSSTP& GibbsExcessVPSSTP::operator=(const GibbsExcessVPSSTP& b)
return *this;
}
//=========================================================================================================================
ThermoPhase* GibbsExcessVPSSTP::duplMyselfAsThermoPhase() const
{
return new GibbsExcessVPSSTP(*this);
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setMassFractions(const doublereal* const y)
{
Phase::setMassFractions(y);
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setMassFractions_NoNorm(const doublereal* const y)
{
Phase::setMassFractions_NoNorm(y);
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setMoleFractions(const doublereal* const x)
{
Phase::setMoleFractions(x);
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setMoleFractions_NoNorm(const doublereal* const x)
{
Phase::setMoleFractions_NoNorm(x);
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setConcentrations(const doublereal* const c)
{
Phase::setConcentrations(c);
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
/*
* ------------ Mechanical Properties ------------------------------
*/
//=========================================================================================================================
void GibbsExcessVPSSTP::setPressure(doublereal p)
{
setState_TP(temperature(), p);
}
//=========================================================================================================================
void GibbsExcessVPSSTP::calcDensity()
{
vector_fp vbar = getPartialMolarVolumesVector();
@ -106,7 +105,7 @@ void GibbsExcessVPSSTP::calcDensity()
doublereal dd = meanMolecularWeight() / vtotal;
Phase::setDensity(dd);
}
//=========================================================================================================================
void GibbsExcessVPSSTP::setState_TP(doublereal t, doublereal p)
{
Phase::setTemperature(t);
@ -125,7 +124,7 @@ void GibbsExcessVPSSTP::setState_TP(doublereal t, doublereal p)
*/
calcDensity();
}
//=========================================================================================================================
/*
* - Activities, Standard States, Activity Concentrations -----------
*/
@ -133,17 +132,17 @@ void GibbsExcessVPSSTP::getActivityConcentrations(doublereal* c) const
{
getActivities(c);
}
//=========================================================================================================================
doublereal GibbsExcessVPSSTP::standardConcentration(size_t k) const
{
return 1.0;
}
//=========================================================================================================================
doublereal GibbsExcessVPSSTP::logStandardConc(size_t k) const
{
return 0.0;
}
//=========================================================================================================================
void GibbsExcessVPSSTP::getActivities(doublereal* ac) const
{
getActivityCoefficients(ac);
@ -152,7 +151,7 @@ void GibbsExcessVPSSTP::getActivities(doublereal* ac) const
ac[k] *= moleFractions_[k];
}
}
//=========================================================================================================================
void GibbsExcessVPSSTP::getActivityCoefficients(doublereal* const ac) const
{
getLnActivityCoefficients(ac);
@ -199,7 +198,7 @@ void GibbsExcessVPSSTP::getActivityCoefficients(doublereal* const ac) const
}
}
}
//=========================================================================================================================
void GibbsExcessVPSSTP::getElectrochemPotentials(doublereal* mu) const
{
getChemPotentials(mu);
@ -208,11 +207,10 @@ void GibbsExcessVPSSTP::getElectrochemPotentials(doublereal* mu) const
mu[k] += ve*charge(k);
}
}
//=========================================================================================================================
/*
* ------------ Partial Molar Properties of the Solution ------------
*/
//=========================================================================================================================
void GibbsExcessVPSSTP::getPartialMolarVolumes(doublereal* vbar) const
{
/*
@ -220,12 +218,12 @@ void GibbsExcessVPSSTP::getPartialMolarVolumes(doublereal* vbar) const
*/
getStandardVolumes(vbar);
}
//=========================================================================================================================
const vector_fp& GibbsExcessVPSSTP::getPartialMolarVolumesVector() const
{
return getStandardVolumes();
}
//=========================================================================================================================
double GibbsExcessVPSSTP::checkMFSum(const doublereal* const x) const
{
doublereal norm = std::accumulate(x, x + m_kk, 0.0);
@ -235,7 +233,7 @@ double GibbsExcessVPSSTP::checkMFSum(const doublereal* const x) const
}
return norm;
}
//=========================================================================================================================
void GibbsExcessVPSSTP::getUnitsStandardConc(double* uA, int k, int sizeUA) const
{
//
@ -263,14 +261,14 @@ void GibbsExcessVPSSTP::getUnitsStandardConc(double* uA, int k, int sizeUA) cons
}
}
}
//=========================================================================================================================
void GibbsExcessVPSSTP::initThermo()
{
initLengths();
VPStandardStateTP::initThermo();
getMoleFractions(DATA_PTR(moleFractions_));
}
//=========================================================================================================================
void GibbsExcessVPSSTP::initLengths()
{
m_kk = nSpecies();
@ -283,5 +281,5 @@ void GibbsExcessVPSSTP::initLengths()
dlnActCoeffdlnN_.resize(m_kk, m_kk);
m_pp.resize(m_kk);
}
//=========================================================================================================================
} // end of namespace Cantera

7
src/thermo/MargulesVPSSTP.cpp
View file

@ -673,7 +673,7 @@ void MargulesVPSSTP::getdlnActCoeffdlnN(const size_t ld, doublereal* dlnActCoeff
}
}
}
//=====================================================================================================================
void MargulesVPSSTP::resizeNumInteractions(const size_t num)
{
numBinaryInteractions_ = num;
@ -693,7 +693,7 @@ void MargulesVPSSTP::resizeNumInteractions(const size_t num)
m_pSpecies_A_ij.resize(num, npos);
m_pSpecies_B_ij.resize(num, npos);
}
//=====================================================================================================================
void MargulesVPSSTP::readXMLBinarySpecies(XML_Node& xmLBinarySpecies)
{
string xname = xmLBinarySpecies.name();
@ -824,6 +824,5 @@ void MargulesVPSSTP::readXMLBinarySpecies(XML_Node& xmLBinarySpecies)
}
}
}
//=====================================================================================================================
}
//=====================================================================================================================

13
src/thermo/MaskellSolidSolnPhase.cpp
View file

@ -18,7 +18,7 @@
namespace Cantera
{
//=====================================================================================================
MaskellSolidSolnPhase::MaskellSolidSolnPhase() :
m_Pref(OneAtm),
m_Pcurrent(OneAtm),
@ -31,7 +31,7 @@ MaskellSolidSolnPhase::MaskellSolidSolnPhase() :
reactant_species_index(1)
{
}
//=====================================================================================================
MaskellSolidSolnPhase::MaskellSolidSolnPhase(const MaskellSolidSolnPhase& b) :
m_Pref(OneAtm),
m_Pcurrent(OneAtm),
@ -45,7 +45,7 @@ MaskellSolidSolnPhase::MaskellSolidSolnPhase(const MaskellSolidSolnPhase& b) :
{
*this = b;
}
//=====================================================================================================
MaskellSolidSolnPhase&
MaskellSolidSolnPhase::operator=(const MaskellSolidSolnPhase& b)
{
@ -54,12 +54,12 @@ MaskellSolidSolnPhase::operator=(const MaskellSolidSolnPhase& b)
}
return *this;
}
//=====================================================================================================
ThermoPhase* MaskellSolidSolnPhase::duplMyselfAsThermoPhase() const
{
return new MaskellSolidSolnPhase(*this);
}
//=====================================================================================================
void MaskellSolidSolnPhase::getActivityConcentrations(doublereal* c) const
{
getActivityCoefficients(c);
@ -72,7 +72,6 @@ void MaskellSolidSolnPhase::getActivityConcentrations(doublereal* c) const
/********************************************************************
* Molar Thermodynamic Properties of the Solution
********************************************************************/
//=====================================================================================================
doublereal MaskellSolidSolnPhase::enthalpy_mole() const
{
_updateThermo();
@ -81,7 +80,7 @@ doublereal MaskellSolidSolnPhase::enthalpy_mole() const
const doublereal fmval = fm(r);
return h0 + r * fmval * h_mixing;
}
//=====================================================================================================
doublereal xlogx(doublereal x)
{
return x * std::log(x);

11
src/thermo/PDSS_HKFT.cpp
View file

@ -22,18 +22,13 @@
using namespace std;
using namespace ctml;
namespace Cantera
{
//==================================================================================================================================
/*
* Set the default to error exit if there is an input file inconsistency
*/
int PDSS_HKFT::s_InputInconsistencyErrorExit = 1;
//==================================================================================================================================
PDSS_HKFT::PDSS_HKFT(VPStandardStateTP* tp, size_t spindex) :
PDSS(tp, spindex),
m_waterSS(0),
@ -63,7 +58,7 @@ PDSS_HKFT::PDSS_HKFT(VPStandardStateTP* tp, size_t spindex) :
m_presR_bar = OneAtm * 1.0E-5;
m_presR_bar = 1.0;
}
//==========================================================================================================================
PDSS_HKFT::PDSS_HKFT(VPStandardStateTP* tp, size_t spindex,
const std::string& inputFile, const std::string& id) :
PDSS(tp, spindex),
@ -557,7 +552,7 @@ void PDSS_HKFT::initAllPtrs(VPStandardStateTP* vptp_ptr, VPSSMgr* vpssmgr_ptr,
delete m_waterProps;
m_waterProps = new WaterProps(m_waterSS);
}
//===================================================================================================================
void PDSS_HKFT::constructPDSSXML(VPStandardStateTP* tp, size_t spindex,
const XML_Node& speciesNode,
const XML_Node& phaseNode, bool spInstalled)
@ -1137,5 +1132,5 @@ void PDSS_HKFT::reportParams(size_t& kindex, int& type,
c[9] = m_c2;
c[10] = m_omega_pr_tr;
}
//============================================================================================================
}

1
src/thermo/ThermoFactory.cpp
View file

@ -207,7 +207,6 @@ ThermoPhase* newPhase(const std::string& infile, std::string id)
return newPhase(*xphase);
}
//====================================================================================================================
//! Gather a vector of pointers to XML_Nodes for a phase
/*!
* @param spDataNodeList Output vector of pointer to XML_Nodes which contain the species XML_Nodes for the

5
src/thermo/VPStandardStateTP.cpp
View file

@ -103,7 +103,7 @@ VPStandardStateTP::operator=(const VPStandardStateTP& b)
}
return *this;
}
//====================================================================================================================
VPStandardStateTP::~VPStandardStateTP()
{
for (int k = 0; k < (int) m_PDSS_storage.size(); k++) {
@ -150,13 +150,12 @@ void VPStandardStateTP::getEnthalpy_RT(doublereal* hrt) const
m_VPSS_ptr->getEnthalpy_RT(hrt);
}
//================================================================================================
void VPStandardStateTP::modifyOneHf298SS(const size_t k, const doublereal Hf298New)
{
m_spthermo->modifyOneHf298(k, Hf298New);
m_Tlast_ss += 0.0001234;
}
//================================================================================================
void VPStandardStateTP::getEntropy_R(doublereal* srt) const
{
updateStandardStateThermo();

2
src/transport/LiquidTransport.cpp
View file

@ -211,7 +211,7 @@ LiquidTransport::~LiquidTransport()
delete m_lambdaMixModel;
delete m_diffMixModel;
}
//=============================================================================================================================
bool LiquidTransport::initLiquid(LiquidTransportParams& tr)
{
//