diff --git a/Cantera/src/base/ctml.cpp b/Cantera/src/base/ctml.cpp index 640cfa5dd..8de42e90f 100644 --- a/Cantera/src/base/ctml.cpp +++ b/Cantera/src/base/ctml.cpp @@ -878,7 +878,7 @@ namespace ctml { * @param v Output vector of floats containing the floatArray information. * @param convert Conversion to SI is carried out if this boolean is * True. The default is true. - * @param typeString String name of the type attribute. This is an optional + * @param unitsString String name of the type attribute. This is an optional * parameter. The default is to have an empty string. * The only string that is recognized is actEnergy. * Anything else has no effect. This affects what @@ -888,8 +888,9 @@ namespace ctml { * * @return Returns the number of floats read */ - int getFloatArray(const Cantera::XML_Node& node, vector_fp& v, const bool convert, - const std::string unitsString, const std::string nodeName) { + int getFloatArray(const Cantera::XML_Node& node, Cantera::vector_fp& v, + const bool convert, const std::string unitsString, + const std::string nodeName) { string::size_type icom; string numstr; doublereal dtmp; diff --git a/Cantera/src/base/ctml.h b/Cantera/src/base/ctml.h index 2fe84d95b..85d6f8a3b 100644 --- a/Cantera/src/base/ctml.h +++ b/Cantera/src/base/ctml.h @@ -358,7 +358,7 @@ namespace ctml { * @param v Output vector of floats containing the floatArray information. * @param convert Conversion to SI is carried out if this boolean is * True. The default is true. - * @param typeString String name of the type attribute. This is an optional + * @param unitsString String name of the type attribute. This is an optional * parameter. The default is to have an empty string. * The only string that is recognized is actEnergy. * Anything else has no effect. This affects what @@ -368,7 +368,7 @@ namespace ctml { * @return Returns the number of floats read into v. */ int getFloatArray(const Cantera::XML_Node& node, Cantera::vector_fp& v, - const bool convert=true, const std::string typeString="", + const bool convert=true, const std::string unitsString="", const std::string nodeName = "floatArray"); //! This function interprets the value portion of an XML element diff --git a/Cantera/src/base/misc.cpp b/Cantera/src/base/misc.cpp index 7aa434eb2..c116b604d 100644 --- a/Cantera/src/base/misc.cpp +++ b/Cantera/src/base/misc.cpp @@ -486,6 +486,8 @@ namespace Cantera { //! Typedef for map between a thread and the message typedef std::map< cthreadId_t, pMessages_t > threadMsgMap_t ; + //! Class that stores thread messages for each thread, and retrieves them + //! based on the thread id. class ThreadMessages { public: diff --git a/Cantera/src/equil/MultiPhase.h b/Cantera/src/equil/MultiPhase.h index cedb1f06f..85ad8a6ae 100644 --- a/Cantera/src/equil/MultiPhase.h +++ b/Cantera/src/equil/MultiPhase.h @@ -824,6 +824,11 @@ namespace Cantera { vector_int & orderVectorElements); #ifdef DEBUG_MODE + //! External int that is used to turn on debug printing for the + //! BasisOptimze program. + /*! + * Set this to 1 if you want debug printing from BasisOptimize. + */ extern int BasisOptimize_print_lvl; #endif } diff --git a/Cantera/src/kinetics/GRI_30_Kinetics.cpp b/Cantera/src/kinetics/GRI_30_Kinetics.cpp index dd01e524d..1d5a1ba85 100644 --- a/Cantera/src/kinetics/GRI_30_Kinetics.cpp +++ b/Cantera/src/kinetics/GRI_30_Kinetics.cpp @@ -85,8 +85,8 @@ namespace Cantera { } - void GRI_30_Kinetics::update_rates(double t, double tlog, double* rf) { - double rt = 1.0/t; + void GRI_30_Kinetics::update_rates(doublereal t, doublereal tlog, doublereal * rf) { + doublereal rt = 1.0/t; rf[0] = exp(25.5108 + -1 * tlog); rf[1] = exp(26.9379 + -1 * tlog); rf[2] = exp(3.65584 + 2.7 * tlog - 3150.48 * rt); @@ -291,7 +291,7 @@ namespace Cantera { } - void GRI_30_Kinetics::update_kc(const double* a, double exp_c0, double* rkc) { + void GRI_30_Kinetics::update_kc(const doublereal * a, doublereal exp_c0, doublereal * rkc) { rkc[0] = a[3]*exp_c0/(a[2]*a[2]); rkc[1] = a[4]*exp_c0/(a[1]*a[2]); rkc[2] = a[1]*a[4]/(a[0]*a[2]); @@ -604,7 +604,7 @@ namespace Cantera { } - void GRI_30_Kinetics::get_wdot(const double* rop, double* wdot) { + void GRI_30_Kinetics::get_wdot(const doublereal * rop, doublereal * wdot) { wdot[0] = - rop[2] + rop[7] + rop[38] + rop[39] + rop[40] + rop[41] + rop[44] + rop[46] + rop[48] + rop[50] + rop[52] + rop[54] + rop[57] + rop[59] + rop[64] + rop[67] + rop[68] + rop[72] + rop[74] + rop[76] + rop[77] + rop[79] - rop[82] - rop[83] - rop[125] - rop[135] + rop[136] - rop[145] - rop[171] + rop[173] + rop[190] + rop[196] + rop[201] + rop[208] + rop[213] - rop[220] + rop[265] + rop[275] + rop[276] + rop[283] + rop[287] - rop[288] + rop[292] + rop[298] + rop[299] + rop[308] + rop[313]; wdot[1] = - rop[1] + rop[2] + rop[5] + rop[6] + rop[8] + rop[9] + rop[13] + rop[20] + rop[23] + rop[27] - rop[32] - rop[33] - rop[34] - rop[35] - rop[36] - rop[37] - 2*rop[38] - 2*rop[39] - 2*rop[40] - 2*rop[41] - rop[42] - rop[43] - rop[44] - rop[45] - rop[46] - rop[47] - rop[48] - rop[49] - rop[50] - rop[51] - rop[52] - rop[53] - rop[54] - rop[55] - rop[56] - rop[57] - rop[58] - rop[59] - rop[60] - rop[61] - rop[62] - rop[64] - rop[65] - rop[66] - rop[67] - rop[68] - rop[69] - rop[70] - rop[71] - rop[72] - rop[73] - rop[74] - rop[75] - rop[76] - rop[77] - rop[78] - rop[79] - rop[80] + rop[83] + rop[89] + rop[90] + rop[91] + rop[93] + rop[98] + rop[105] + rop[106] + rop[107] + rop[122] + rop[123] + rop[125] + rop[126] + rop[127] + rop[128] + rop[129] + rop[132] + rop[134] + rop[135] + rop[137] + rop[143] + rop[145] + rop[148] + rop[158] + rop[165] + rop[166] + rop[171] + rop[179] - rop[182] - rop[188] + rop[189] - rop[190] + rop[191] + rop[195] + rop[198] + rop[200] - rop[201] + rop[203] + rop[204] - rop[208] - rop[211] - rop[213] + rop[217] + rop[220] - rop[222] + rop[223] + rop[229] + rop[230] + rop[233] + rop[234] - rop[236] + rop[246] + rop[248] + rop[250] + rop[251] + rop[253] + rop[256] + rop[259] - rop[260] - rop[264] - rop[265] - rop[270] - rop[271] + rop[274] - rop[276] + rop[283] + rop[284] + rop[285] + 2*rop[289] + 2*rop[291] - rop[298] - rop[299] - rop[303] + rop[304] - rop[307] - rop[308] - rop[313] - rop[319] - rop[320]; wdot[2] = - 2*rop[0] - rop[1] - rop[2] - rop[3] - rop[4] - rop[5] - rop[6] - rop[7] - rop[8] - rop[9] - rop[10] - rop[11] - rop[12] - rop[13] - rop[14] - rop[15] - rop[16] - rop[17] - rop[18] - rop[19] - rop[20] - rop[21] - rop[22] - rop[23] - rop[24] - rop[25] - rop[26] - rop[27] - rop[28] - rop[29] + rop[30] + rop[37] + rop[43] + rop[85] + rop[121] + rop[124] + rop[154] + rop[177] + rop[178] - rop[180] - rop[181] + rop[184] - rop[186] - rop[187] - rop[189] + rop[193] - rop[199] - rop[200] - rop[206] - rop[207] - rop[212] - rop[216] + rop[219] - rop[221] - rop[230] - rop[231] - rop[232] + rop[243] + rop[245] - rop[256] - rop[257] + rop[258] - rop[261] - rop[262] - rop[263] - rop[278] - rop[283] - rop[284] - rop[285] + rop[290] + rop[293] - rop[295] - rop[296] - rop[304] - rop[312] - rop[318]; @@ -661,7 +661,7 @@ namespace Cantera { } - void GRI_30_Kinetics::eval_ropnet(const double* c, const double* rf, const double* rkc, double* r) { + void GRI_30_Kinetics::eval_ropnet(const doublereal * c, const doublereal * rf, const doublereal * rkc, doublereal * r) { r[0] = rf[0] * (c[2] * c[2] - rkc[0] * c[3]); r[1] = rf[1] * (c[2] * c[1] - rkc[1] * c[4]); r[2] = rf[2] * (c[2] * c[0] - rkc[2] * c[1] * c[4]); diff --git a/Cantera/src/kinetics/GRI_30_Kinetics.h b/Cantera/src/kinetics/GRI_30_Kinetics.h index 094c61289..98494f1f2 100644 --- a/Cantera/src/kinetics/GRI_30_Kinetics.h +++ b/Cantera/src/kinetics/GRI_30_Kinetics.h @@ -42,10 +42,10 @@ namespace Cantera { void gri30_update_rates_T(); void gri30_updateROP(); void gri30_updateKc(); - void get_wdot(const doublereal* rop, doublereal* wdot); - void update_kc(const double* grt, double c0, double* rkc); - void update_rates(double t, double tlog, double* rf); - void eval_ropnet(const double* c, const double* rf, const double* rkc, double* r); + void get_wdot(const doublereal * rop, doublereal * wdot); + void update_kc(const doublereal * grt, doublereal c0, doublereal * rkc); + void update_rates(doublereal t, doublereal tlog, doublereal * rf); + void eval_ropnet(const doublereal * c, const doublereal * rf, const doublereal * rkc, doublereal * r); }; } diff --git a/Cantera/src/kinetics/GasKineticsWriter.h b/Cantera/src/kinetics/GasKineticsWriter.h index 88b07a213..ccfb8486c 100644 --- a/Cantera/src/kinetics/GasKineticsWriter.h +++ b/Cantera/src/kinetics/GasKineticsWriter.h @@ -63,7 +63,7 @@ namespace Cantera { void writeGetNetProductionRates(std::ostream& s, int nsp, int nrxns) { int i, k; - s << "void get_wdot(const double* rop, double* wdot) {" << std::endl; + s << "void get_wdot(const doublereal * rop, doublereal * wdot) {" << std::endl; for (k = 0; k < nsp; k++) { s << " wdot[" << k << "] = "; doublereal net; @@ -94,8 +94,8 @@ namespace Cantera { void writeUpdateKc(std::ostream& s, int nsp, int nrxns) { int i, k, n, nn, ir; - s << "void update_kc(const double* a, " - "double exp_c0, double* rkc) {" << endl; + s << "void update_kc(const doublereal * a, " + "doublereal exp_c0, doublereal* rkc) {" << endl; for (i = 0; i != m_nrev; i++) { //if (isReversible(i)) { ir = m_revindex[i]; @@ -134,8 +134,8 @@ namespace Cantera { void writeEvalRopnet(std::ostream& s) { int i; - s << "void eval_ropnet(const double* c, " - "const double* rf, const double* rkc, double* r) {" << endl; + s << "void eval_ropnet(const doublereal* c, " + "const doublereal * rf, const doublereal * rkc, doublereal* r) {" << endl; for (i = 0; i < m_ii; i++) { s << " r[" << i << "] = rf[" << i << "] * (" << m_reactantWriter.mult(i); @@ -151,8 +151,8 @@ namespace Cantera { void writeUpdateRates(std::ostream& s) { - s << "void update_rates(double t, double tlog, double* rf) {" << endl; - s << " double rt = 1.0/t;" << endl; + s << "void update_rates(doublereal t, doublereal tlog, doublereal * rf) {" << endl; + s << " doublereal rt = 1.0/t;" << endl; m_rates.writeUpdate(s, "rf"); s << "}" << endl; } diff --git a/Cantera/src/kinetics/ImplicitChem.cpp b/Cantera/src/kinetics/ImplicitChem.cpp index 5a05e2f76..58192ffb7 100644 --- a/Cantera/src/kinetics/ImplicitChem.cpp +++ b/Cantera/src/kinetics/ImplicitChem.cpp @@ -38,7 +38,7 @@ namespace Cantera { // overloaded method of FuncEval. Called by the integrator to // get the initial conditions. - void ImplicitChem::getInitialConditions(double t0, size_t leny, double* y) + void ImplicitChem::getInitialConditions(doublereal t0, size_t leny, doublereal * y) { m_thermo->getMassFractions(y); m_h0 = m_thermo->enthalpy_mass(); diff --git a/Cantera/src/kinetics/ImplicitSurfChem.cpp b/Cantera/src/kinetics/ImplicitSurfChem.cpp index 28e82d45a..8334ae95f 100644 --- a/Cantera/src/kinetics/ImplicitSurfChem.cpp +++ b/Cantera/src/kinetics/ImplicitSurfChem.cpp @@ -132,8 +132,8 @@ namespace Cantera { // overloaded method of FuncEval. Called by the integrator to // get the initial conditions. - void ImplicitSurfChem::getInitialConditions(double t0, size_t lenc, - double* c) + void ImplicitSurfChem::getInitialConditions(doublereal t0, size_t lenc, + doublereal * c) { int loc = 0; for (int n = 0; n < m_nsurf; n++) { @@ -234,7 +234,7 @@ namespace Cantera { /* * time scale - time over which to integrate equations */ - double time_scale = timeScaleOverride; + doublereal time_scale = timeScaleOverride; /* * */ @@ -263,8 +263,8 @@ namespace Cantera { getConcSpecies(DATA_PTR(m_concSpecies)); InterfaceKinetics *ik = m_vecKinPtrs[0]; ThermoPhase &tp = ik->thermo(0); - double TKelvin = tp.temperature(); - double PGas = tp.pressure(); + doublereal TKelvin = tp.temperature(); + doublereal PGas = tp.pressure(); /* * Make sure that there is a common temperature and * pressure for all ThermoPhase objects belonging to the @@ -275,8 +275,8 @@ namespace Cantera { setCommonState_TP(TKelvin, PGas); } - double reltol = 1.0E-6; - double atol = 1.0E-20; + doublereal reltol = 1.0E-6; + doublereal atol = 1.0E-20; /* * Install a filter for negative concentrations. One of the @@ -379,7 +379,7 @@ namespace Cantera { * Pressure = Pascal */ void ImplicitSurfChem:: - setCommonState_TP(double TKelvin, double PresPa) { + setCommonState_TP(doublereal TKelvin, doublereal PresPa) { int nphases = m_nsurf; for (int ip = 0; ip < nphases; ip++) { ThermoPhase *TP_ptr = m_surf[ip]; diff --git a/Cantera/src/kinetics/ImplicitSurfChem.h b/Cantera/src/kinetics/ImplicitSurfChem.h index adc0fcdce..4074f4de5 100644 --- a/Cantera/src/kinetics/ImplicitSurfChem.h +++ b/Cantera/src/kinetics/ImplicitSurfChem.h @@ -212,7 +212,7 @@ namespace Cantera { * @param TKelvin input temperature (kelvin) * @param PresPa input pressure in pascal. */ - void setCommonState_TP(double TKelvin, double PresPa); + void setCommonState_TP(doublereal TKelvin, doublereal PresPa); //! Returns a reference to the vector of pointers to the @@ -245,25 +245,25 @@ namespace Cantera { * The lenth is equal to the sum of the number of surface * sites in all the surface phases */ - void updateState(doublereal* y); + void updateState(doublereal *y); //! vector of pointers to surface phases. - std::vector m_surf; + std::vector m_surf; //! Vector of pointers to bulk phases - std::vector m_bulkPhases; + std::vector m_bulkPhases; //! vector of pointers to InterfaceKinetics objects - std::vector m_vecKinPtrs; + std::vector m_vecKinPtrs; //! Vector of number of species in each Surface Phase - vector_int m_nsp; + vector_int m_nsp; //! index of the surface phase in each InterfaceKinetics object - vector_int m_surfindex; + vector_int m_surfindex; - vector_int m_specStartIndex; + vector_int m_specStartIndex; //! Total number of surface phases. /*! diff --git a/Cantera/src/kinetics/InterfaceKinetics.cpp b/Cantera/src/kinetics/InterfaceKinetics.cpp index 98df1c8fd..090b8585e 100644 --- a/Cantera/src/kinetics/InterfaceKinetics.cpp +++ b/Cantera/src/kinetics/InterfaceKinetics.cpp @@ -425,7 +425,7 @@ namespace Cantera { */ doublereal eamod; #ifdef DEBUG_KIN_MODE - double ea; + doublereal ea; #endif int nct = m_beta.size(); int irxn; diff --git a/Cantera/src/kinetics/InterfaceKinetics.h b/Cantera/src/kinetics/InterfaceKinetics.h index 3de46a1f1..c1b0343a8 100644 --- a/Cantera/src/kinetics/InterfaceKinetics.h +++ b/Cantera/src/kinetics/InterfaceKinetics.h @@ -38,8 +38,9 @@ namespace Cantera { class ImplicitSurfChem; - /** - * Holds mechanism-specific data. + //! This class holds mechanism-specific data. + /*! + * */ class InterfaceKineticsData { public: @@ -47,9 +48,11 @@ namespace Cantera { m_ROP_ok(false), m_temp(0.0), m_logtemp(0.0) {} + //! Virtual destructor virtual ~InterfaceKineticsData(){} - doublereal m_logp0, m_logc0; + doublereal m_logp0; + doublereal m_logc0; array_fp m_ropf; array_fp m_ropr; array_fp m_ropnet; @@ -629,6 +632,15 @@ namespace Cantera { //! boolean indicating whether mechanism has been finalized bool m_finalized; bool m_has_coverage_dependence; + + //! Boolean flag indicating whether any reaction in the mechanism + //! has a beta electrochemical parameter. + /*! + * If this is true, the the Butler-Volmer correction is applied + * to the forward reaction rate for those reactions. + * + * fac = exp ( - beta * (delta_phi)) + */ bool m_has_electrochem_rxns; int m_ioFlag; diff --git a/Cantera/src/kinetics/ReactionPath.cpp b/Cantera/src/kinetics/ReactionPath.cpp index af42f38a2..fc92869da 100644 --- a/Cantera/src/kinetics/ReactionPath.cpp +++ b/Cantera/src/kinetics/ReactionPath.cpp @@ -136,7 +136,7 @@ namespace Cantera { vector_int ReactionPathDiagram::reactions() { int i, npaths = nPaths(); - double flmax = 0.0, flxratio; + doublereal flmax = 0.0, flxratio; Path* p; for (i = 0; i < npaths; i++) { @@ -163,7 +163,7 @@ namespace Cantera { } void ReactionPathDiagram::add(ReactionPathDiagram& d) { -// double f1, f2; +// doublereal f1, f2; // int nnodes = nNodes(); // if (nnodes != d.nNodes()) { // throw CanteraError("ReactionPathDiagram::add", @@ -205,7 +205,7 @@ namespace Cantera { } void ReactionPathDiagram::writeData(ostream& s) { - double f1, f2; + doublereal f1, f2; int nnodes = nNodes(); int i1, i2, k1, k2; s << title << endl; @@ -275,7 +275,7 @@ namespace Cantera { int nnodes = nNodes(); int kbegin, kend, i1, i2, k1, k2; - double flx; + doublereal flx; // draw paths representing net flows if (flow_type == NetFlow) diff --git a/Cantera/src/kinetics/ReactionPath.h b/Cantera/src/kinetics/ReactionPath.h index f2ccf67d6..7cff095e7 100644 --- a/Cantera/src/kinetics/ReactionPath.h +++ b/Cantera/src/kinetics/ReactionPath.h @@ -70,15 +70,16 @@ namespace Cantera { /// add a path to or from this node void addPath(Path* path); - double outflow() {return m_out;} - double inflow() {return m_in;} - double netOutflow() {return m_out - m_in;} + doublereal outflow() {return m_out;} + doublereal inflow() {return m_in;} + doublereal netOutflow() {return m_out - m_in;} void printPaths(); protected: - double m_in, m_out; + doublereal m_in; + doublereal m_out; path_list m_paths; }; @@ -216,10 +217,10 @@ namespace Cantera { doublereal x_size, y_size; std::string name, dot_options; flow_t flow_type; - double scale; - double arrow_width; + doublereal scale; + doublereal arrow_width; bool show_details; - double arrow_hue; + doublereal arrow_hue; protected: diff --git a/Cantera/src/kinetics/RxnRates.h b/Cantera/src/kinetics/RxnRates.h index 44f0c6a70..4e3d495ad 100644 --- a/Cantera/src/kinetics/RxnRates.h +++ b/Cantera/src/kinetics/RxnRates.h @@ -321,7 +321,7 @@ namespace Cantera { } doublereal updateRC(doublereal logT, doublereal recipT) const { - double lres = update(logT, recipT); + doublereal lres = update(logT, recipT); return exp(lres); } diff --git a/Cantera/src/kinetics/importKinetics.cpp b/Cantera/src/kinetics/importKinetics.cpp index fd6b5a1c4..e40a1df84 100644 --- a/Cantera/src/kinetics/importKinetics.cpp +++ b/Cantera/src/kinetics/importKinetics.cpp @@ -96,7 +96,7 @@ namespace Cantera { void checkRxnElementBalance(Kinetics& kin, const ReactionData &rdata, doublereal errorTolerance) { int index, klocal, n, kp, kr, m, nel; - double kstoich; + doublereal kstoich; map bal, balr, balp; bal.clear(); @@ -351,8 +351,8 @@ namespace Cantera { int ispKinetics = kin.kineticsSpeciesIndex(spname); int ispPhaseIndex = kin.speciesPhaseIndex(ispKinetics); - double ispMW = th.molecularWeights()[isp]; - double sc; + doublereal ispMW = th.molecularWeights()[isp]; + doublereal sc; // loop over the reactants for (int n = 0; n < nr; n++) { @@ -760,9 +760,9 @@ namespace Cantera { int np = rdata.products.size(); for (int i = 0; i < np; i++) { int k = rdata.products[i]; - double po = rdata.porder[i]; + doublereal po = rdata.porder[i]; AssertTrace(po == rdata.pstoich[i]); - double chk = po - 1.0 * int(po); + doublereal chk = po - 1.0 * int(po); if (chk != 0.0) { /* * put in a check here that k is a single species phase. @@ -779,9 +779,9 @@ namespace Cantera { int nr = rdata.reactants.size(); for (int i = 0; i < nr; i++) { int k = rdata.reactants[i]; - double ro = rdata.rorder[i]; + doublereal ro = rdata.rorder[i]; AssertTrace(ro == rdata.rstoich[i]); - double chk = ro - 1.0 * int(ro); + doublereal chk = ro - 1.0 * int(ro); if (chk != 0.0) { /* * put in a check here that k is a single species phase. diff --git a/Cantera/src/kinetics/solveSP.cpp b/Cantera/src/kinetics/solveSP.cpp index a44757365..660e1dd05 100644 --- a/Cantera/src/kinetics/solveSP.cpp +++ b/Cantera/src/kinetics/solveSP.cpp @@ -30,17 +30,17 @@ namespace Cantera { * STATIC ROUTINES DEFINED IN THIS FILE ***************************************************************************/ - static double calc_damping(double *x, double *dx, int dim, int *); - static double calcWeightedNorm(const double [], const double dx[], int); + static doublereal calc_damping(doublereal *x, doublereal *dx, int dim, int *); + static doublereal calcWeightedNorm(const doublereal [], const doublereal dx[], int); /*************************************************************************** * LAPACK PROTOTYPES ***************************************************************************/ //#define FSUB_TYPE void // extern "C" { - // extern FSUB_TYPE dgetrf_(int *, int *, double *, int *, int [], int *); - // extern FSUB_TYPE dgetrs_(char *, int *, int *, double *, int *, int [], - // double [], int *, int *, unsigned int); + // extern FSUB_TYPE dgetrf_(int *, int *, doublereal *, int *, int [], int *); + // extern FSUB_TYPE dgetrs_(char *, int *, int *, doublereal *, int *, int [], + // doublereal [], int *, int *, unsigned int); // } /***************************************************************************** * PROTOTYPES and PREPROC DIRECTIVES FOR MISC. ROUTINES @@ -208,10 +208,10 @@ namespace Cantera { * surface species production rate = 0 and that the bulk fractions are * proportional to their production rates. */ - int solveSP::solveSurfProb(int ifunc, double time_scale, double TKelvin, - double PGas, double reltol, double abstol) + int solveSP::solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin, + doublereal PGas, doublereal reltol, doublereal abstol) { - double EXTRA_ACCURACY = 0.001; + doublereal EXTRA_ACCURACY = 0.001; if (ifunc == SFLUX_JACOBIAN) { EXTRA_ACCURACY *= 0.001; } @@ -220,24 +220,24 @@ namespace Cantera { int label_t=-1; /* Species IDs for time control */ int label_d; /* Species IDs for damping control */ int label_t_old=-1; - double label_factor = 1.0; + doublereal label_factor = 1.0; int iter=0; // iteration number on numlinear solver int iter_max=1000; // maximum number of nonlinear iterations int nrhs=1; - double deltaT = 1.0E-10; // Delta time step - double damp=1.0, tmp; + doublereal deltaT = 1.0E-10; // Delta time step + doublereal damp=1.0, tmp; // Weighted L2 norm of the residual. Currently, this is only // used for IO purposes. It doesn't control convergence. // Therefore, it is turned off when DEBUG_SOLVESP isn't defined. - double resid_norm; - double inv_t = 0.0; - double t_real = 0.0, update_norm = 1.0E6; + doublereal resid_norm; + doublereal inv_t = 0.0; + doublereal t_real = 0.0, update_norm = 1.0E6; bool do_time = false, not_converged = true; #ifdef DEBUG_SOLVESP #ifdef DEBUG_SOLVESP_TIME - double t1; + doublereal t1; #endif #else if (m_ioflag > 1) { @@ -548,7 +548,7 @@ namespace Cantera { /* * Update the surface states of the surface phases. */ - void solveSP::updateState(const double *CSolnSP) { + void solveSP::updateState(const doublereal *CSolnSP) { int loc = 0; for (int n = 0; n < m_numSurfPhases; n++) { m_ptrsSurfPhase[n]->setConcentrations(CSolnSP + loc); @@ -565,7 +565,7 @@ namespace Cantera { /* * Update the mole fractions for phases which are part of the equation set */ - void solveSP::updateMFSolnSP(double *XMolSolnSP) { + void solveSP::updateMFSolnSP(doublereal *XMolSolnSP) { for (int isp = 0; isp < m_numSurfPhases; isp++) { int keqnStart = m_eqnIndexStartSolnPhase[isp]; m_ptrsSurfPhase[isp]->getMoleFractions(XMolSolnSP + keqnStart); @@ -582,7 +582,7 @@ namespace Cantera { * Update the mole fractions for phases which are part of a single * interfacial kinetics object */ - void solveSP::updateMFKinSpecies(double *XMolKinSpecies, int isp) { + void solveSP::updateMFKinSpecies(doublereal *XMolKinSpecies, int isp) { InterfaceKinetics *m_kin = m_objects[isp]; int nph = m_kin->nPhases(); for (int iph = 0; iph < nph; iph++) { @@ -596,11 +596,11 @@ namespace Cantera { * Update the vector that keeps track of the largest species in each * surface phase. */ - void solveSP::evalSurfLarge(const double *CSolnSP) { + void solveSP::evalSurfLarge(const doublereal *CSolnSP) { int kindexSP = 0; for (int isp = 0; isp < m_numSurfPhases; isp++) { int nsp = m_nSpeciesSurfPhase[isp]; - double Clarge = CSolnSP[kindexSP]; + doublereal Clarge = CSolnSP[kindexSP]; m_spSurfLarge[isp] = 0; kindexSP++; for (int k = 1; k < nsp; k++, kindexSP++) { @@ -622,14 +622,14 @@ namespace Cantera { * This routine uses the m_numEqn1 and m_netProductionRatesSave vectors * as temporary internal storage. */ - void solveSP::fun_eval(double* resid, const double *CSoln, - const double *CSolnOld, const bool do_time, - const double deltaT) + void solveSP::fun_eval(doublereal * resid, const doublereal *CSoln, + const doublereal *CSolnOld, const bool do_time, + const doublereal deltaT) { int isp, nsp, kstart, k, kindexSP, kins, kspecial; - double lenScale = 1.0E-9; - double sd = 0.0; - double grRate; + doublereal lenScale = 1.0E-9; + doublereal sd = 0.0; + doublereal grRate; if (m_numSurfPhases > 0) { /* * update the surface concentrations with the input surface @@ -690,7 +690,7 @@ namespace Cantera { if (m_bulkFunc == BULK_DEPOSITION) { kindexSP = m_numTotSurfSpecies; for (isp = 0; isp < m_numBulkPhasesSS; isp++) { - double *XBlk = DATA_PTR(m_numEqn1); + doublereal *XBlk = DATA_PTR(m_numEqn1); //ThermoPhase *THptr = m_bulkPhasePtrs[isp]; //THptr->getMoleFractions(XBlk); nsp = m_nSpeciesSurfPhase[isp]; @@ -743,14 +743,14 @@ namespace Cantera { * This routine uses the m_numEqn2 vector * as temporary internal storage. */ - void solveSP::resjac_eval(std::vector &JacCol, - double resid[], double CSoln[], - const double CSolnOld[], const bool do_time, - const double deltaT) + void solveSP::resjac_eval(std::vector &JacCol, + doublereal resid[], doublereal CSoln[], + const doublereal CSolnOld[], const bool do_time, + const doublereal deltaT) { int kColIndex = 0, nsp, jsp, i, kCol; - double dc, cSave, sd; - double *col_j; + doublereal dc, cSave, sd; + doublereal *col_j; /* * Calculate the residual */ @@ -798,7 +798,7 @@ namespace Cantera { #define APPROACH 0.80 - static double calc_damping(double x[], double dxneg[], int dim, int *label) + static doublereal calc_damping(doublereal x[], doublereal dxneg[], int dim, int *label) /* This function calculates a damping factor for the Newton iteration update * vector, dxneg, to insure that all site and bulk fractions, x, remain @@ -813,8 +813,8 @@ namespace Cantera { { int i; - double damp = 1.0, xnew, xtop, xbot; - static double damp_old = 1.0; + doublereal damp = 1.0, xnew, xtop, xbot; + static doublereal damp_old = 1.0; *label = -1; @@ -873,9 +873,9 @@ namespace Cantera { * This function calculates the norm of an update, dx[], * based on the weighted values of x. */ - static double calcWeightedNorm(const double wtX[], const double dx[], int dim) { - double norm = 0.0; - double tmp; + static doublereal calcWeightedNorm(const doublereal wtX[], const doublereal dx[], int dim) { + doublereal norm = 0.0; + doublereal tmp; if (dim == 0) return 0.0; for (int i = 0; i < dim; i++) { tmp = dx[i] / wtX[i]; @@ -889,12 +889,12 @@ namespace Cantera { * concentration unknowns and the residual unknowns. * */ - void solveSP::calcWeights(double wtSpecies[], double wtResid[], - const Array2D &Jac, const double CSoln[], - const double abstol, const double reltol) + void solveSP::calcWeights(doublereal wtSpecies[], doublereal wtResid[], + const Array2D &Jac, const doublereal CSoln[], + const doublereal abstol, const doublereal reltol) { int k, jcol, kindex, isp, nsp; - double sd; + doublereal sd; /* * First calculate the weighting factor for the concentrations of * the surface species and bulk species. @@ -941,13 +941,13 @@ namespace Cantera { * * Maximum time step set to time_scale. */ - double solveSP:: - calc_t(double netProdRateSolnSP[], double XMolSolnSP[], - int *label, int *label_old, double *label_factor, int ioflag) + doublereal solveSP:: + calc_t(doublereal netProdRateSolnSP[], doublereal XMolSolnSP[], + int *label, int *label_old, doublereal *label_factor, int ioflag) { int k, isp, nsp, kstart; - double inv_timeScale = 1.0E-10; - double sden, tmp; + doublereal inv_timeScale = 1.0E-10; + doublereal sden, tmp; int kindexSP = 0; *label = 0; int ispSpecial = 0; @@ -1025,8 +1025,8 @@ namespace Cantera { */ #ifdef DEBUG_SOLVESP void solveSP::printResJac(int ioflag, int neq, const Array2D &Jac, - double resid[], double wtRes[], - double norm) + doublereal resid[], doublereal wtRes[], + doublereal norm) { int i, j, isp, nsp, irowKSI, irowISP; int kstartKSI; @@ -1085,11 +1085,11 @@ namespace Cantera { /* * Optional printing at the start of the solveSP problem */ - void solveSP::print_header(int ioflag, int ifunc, double time_scale, - int damping, double reltol, double abstol, - double TKelvin, - double PGas, double netProdRate[], - double XMolKinSpecies[]) { + void solveSP::print_header(int ioflag, int ifunc, doublereal time_scale, + int damping, doublereal reltol, doublereal abstol, + doublereal TKelvin, + doublereal PGas, doublereal netProdRate[], + doublereal XMolKinSpecies[]) { if (ioflag) { printf("\n================================ SOLVESP CALL SETUP " "========================================\n"); @@ -1194,13 +1194,13 @@ namespace Cantera { } } - void solveSP::printIteration(int ioflag, double damp, int label_d, + void solveSP::printIteration(int ioflag, doublereal damp, int label_d, int label_t, - double inv_t, double t_real, int iter, - double update_norm, double resid_norm, - double netProdRate[], double CSolnSP[], - double resid[], double XMolSolnSP[], - double wtSpecies[], int dim, bool do_time) + doublereal inv_t, doublereal t_real, int iter, + doublereal update_norm, doublereal resid_norm, + doublereal netProdRate[], doublereal CSolnSP[], + doublereal resid[], doublereal XMolSolnSP[], + doublereal wtSpecies[], int dim, bool do_time) { int i, k; string nm; @@ -1278,14 +1278,14 @@ namespace Cantera { } /* printIteration */ - void solveSP::printFinal(int ioflag, double damp, int label_d, int label_t, - double inv_t, double t_real, int iter, - double update_norm, double resid_norm, - double netProdRateKinSpecies[], const double CSolnSP[], - const double resid[], double XMolSolnSP[], - const double wtSpecies[], const double wtRes[], + void solveSP::printFinal(int ioflag, doublereal damp, int label_d, int label_t, + doublereal inv_t, doublereal t_real, int iter, + doublereal update_norm, doublereal resid_norm, + doublereal netProdRateKinSpecies[], const doublereal CSolnSP[], + const doublereal resid[], doublereal XMolSolnSP[], + const doublereal wtSpecies[], const doublereal wtRes[], int dim, bool do_time, - double TKelvin, double PGas) + doublereal TKelvin, doublereal PGas) { int i, k; string nm; @@ -1363,7 +1363,7 @@ namespace Cantera { } printf("---------------------------------------------------------------" "---------------------------------------------\n"); - double *XMolKinSpecies = DATA_PTR(m_numEqn2); + doublereal *XMolKinSpecies = DATA_PTR(m_numEqn2); kindexSP = 0; for (int isp = 0; isp < m_numSurfPhases; isp++) { InterfaceKinetics *m_kin = m_objects[isp]; @@ -1417,7 +1417,7 @@ namespace Cantera { #ifdef DEBUG_SOLVESP void solveSP:: - printIterationHeader(int ioflag, double damp,double inv_t, double t_real, + printIterationHeader(int ioflag, doublereal damp,doublereal inv_t, doublereal t_real, int iter, bool do_time) { if (ioflag > 1) { diff --git a/Cantera/src/kinetics/solveSP.h b/Cantera/src/kinetics/solveSP.h index f4d679d3e..d47113175 100644 --- a/Cantera/src/kinetics/solveSP.h +++ b/Cantera/src/kinetics/solveSP.h @@ -249,45 +249,45 @@ namespace Cantera { * Note the actual converged solution is returned as part of the * internal state of the InterfaceKinetics objects. */ - int solveSurfProb(int ifunc, double time_scale, double TKelvin, - double PGas, double reltol, double abstol); + int solveSurfProb(int ifunc, doublereal time_scale, doublereal TKelvin, + doublereal PGas, doublereal reltol, doublereal abstol); private: //! Printing routine that gets called at the start of every //! invocation - void print_header(int ioflag, int ifunc, double time_scale, - int damping, double reltol, double abstol, - double TKelvin, double PGas, double netProdRate[], - double XMolKinSpecies[]); + void print_header(int ioflag, int ifunc, doublereal time_scale, + int damping, doublereal reltol, doublereal abstol, + doublereal TKelvin, doublereal PGas, doublereal netProdRate[], + doublereal XMolKinSpecies[]); #ifdef DEBUG_SOLVESP void printResJac(int ioflag, int neq, const Array2D &Jac, - double resid[], double wtResid[], double norm); + doublereal resid[], doublereal wtResid[], doublereal norm); #endif //! Printing routine that gets called after every iteration - void printIteration(int ioflag, double damp, int label_d, int label_t, - double inv_t, double t_real, int iter, - double update_norm, double resid_norm, - double netProdRate[], double CSolnSP[], - double resid[], double XMolSolnSP[], - double wtSpecies[], int dim, bool do_time); + void printIteration(int ioflag, doublereal damp, int label_d, int label_t, + doublereal inv_t, doublereal t_real, int iter, + doublereal update_norm, doublereal resid_norm, + doublereal netProdRate[], doublereal CSolnSP[], + doublereal resid[], doublereal XMolSolnSP[], + doublereal wtSpecies[], int dim, bool do_time); //! Print a summary of the solution /*! * */ - void printFinal(int ioflag, double damp, int label_d, int label_t, - double inv_t, double t_real, int iter, - double update_norm, double resid_norm, - double netProdRateKinSpecies[], const double CSolnSP[], - const double resid[], double XMolSolnSP[], - const double wtSpecies[], const double wtRes[], + void printFinal(int ioflag, doublereal damp, int label_d, int label_t, + doublereal inv_t, doublereal t_real, int iter, + doublereal update_norm, doublereal resid_norm, + doublereal netProdRateKinSpecies[], const doublereal CSolnSP[], + const doublereal resid[], doublereal XMolSolnSP[], + const doublereal wtSpecies[], const doublereal wtRes[], int dim, bool do_time, - double TKelvin, double PGas); + doublereal TKelvin, doublereal PGas); //! Calculate a conservative delta T to use in a pseudo-steady state //! algorithm @@ -320,9 +320,9 @@ namespace Cantera { * * @return Returns the 1. / delta T to be used on the next step */ - double calc_t(double netProdRateSolnSP[], double XMolSolnSP[], + doublereal calc_t(doublereal netProdRateSolnSP[], doublereal XMolSolnSP[], int *label, int *label_old, - double *label_factor, int ioflag); + doublereal *label_factor, int ioflag); //! Calculate the solution and residual weights /*! @@ -335,9 +335,9 @@ namespace Cantera { * @param abstol Absolute error tolerance * @param reltol Relative error tolerance */ - void calcWeights(double wtSpecies[], double wtResid[], - const Array2D &Jac, const double CSolnSP[], - const double abstol, const double reltol); + void calcWeights(doublereal wtSpecies[], doublereal wtResid[], + const Array2D &Jac, const doublereal CSolnSP[], + const doublereal abstol, const doublereal reltol); #ifdef DEBUG_SOLVESP //! Utility routine to print a header for high lvls of debugging @@ -350,22 +350,22 @@ namespace Cantera { * @param do_time boolean indicating whether time stepping is taking * place */ - void printIterationHeader(int ioflag, double damp, - double inv_t, double t_real, int iter, + void printIterationHeader(int ioflag, doublereal damp, + doublereal inv_t, doublereal t_real, int iter, bool do_time); #endif /** * Update the surface states of the surface phases. */ - void updateState(const double* cSurfSpec); + void updateState(const doublereal *cSurfSpec); //! Update mole fraction vector consisting of unknowns in surface problem /*! * @param XMolSolnSP Vector of mole fractions for the unknowns in the * surface problem. */ - void updateMFSolnSP(double *XMolSolnSP); + void updateMFSolnSP(doublereal * XMolSolnSP); //! Update the mole fraction vector for a specific kinetic species vector //! corresponding to one InterfaceKinetics object @@ -376,7 +376,7 @@ namespace Cantera { * phases in the InterfaceKinetics object * @param isp ID of the InterfaceKinetics Object. */ - void updateMFKinSpecies(double *XMolKinSp, int isp); + void updateMFKinSpecies(doublereal *XMolKinSp, int isp); //! Update the vector that keeps track of the largest species in each @@ -385,7 +385,7 @@ namespace Cantera { * @param CsolnSP Vector of the current values of the surface concentrations * in all of the surface species. */ - void evalSurfLarge(const double *CSolnSP); + void evalSurfLarge(const doublereal *CSolnSP); //! Main Function evalulation /*! @@ -398,8 +398,8 @@ namespace Cantera { * @param do_time Calculate a time dependent residual * @param deltaT Delta time for time dependent problem. */ - void fun_eval(double* resid, const double *CSolnSP, - const double *CSolnOldSP, const bool do_time, const double deltaT); + void fun_eval(doublereal* resid, const doublereal *CSolnSP, + const doublereal *CSolnOldSP, const bool do_time, const doublereal deltaT); //! Main routine that calculates the current residual and Jacobian /*! @@ -414,10 +414,10 @@ namespace Cantera { * @param do_time Calculate a time dependent residual * @param deltaT Delta time for time dependent problem. */ - void resjac_eval(std::vector& JacCol, double* resid, - double *CSolnSP, - const double *CSolnSPOld, const bool do_time, - const double deltaT); + void resjac_eval(std::vector& JacCol, doublereal * resid, + doublereal *CSolnSP, + const doublereal *CSolnSPOld, const bool do_time, + const doublereal deltaT); //! Pointer to the manager of the implicit surface chemistry //! problem @@ -581,10 +581,10 @@ namespace Cantera { /*! * units are (kmol/m2) */ - double m_atol; + doublereal m_atol; //! m_rtol is the relative error tolerance. - double m_rtol; + doublereal m_rtol; //! maximum value of the time step /*! @@ -669,7 +669,7 @@ namespace Cantera { * The "dim" by "dim" computed Jacobian matrix for the * local Newton's method. */ - std::vector m_JacCol; + std::vector m_JacCol; //! Jacobian /*! diff --git a/Cantera/src/thermo/IonsFromNeutralVPSSTP.cpp b/Cantera/src/thermo/IonsFromNeutralVPSSTP.cpp index aaa88fe7c..df90bac16 100644 --- a/Cantera/src/thermo/IonsFromNeutralVPSSTP.cpp +++ b/Cantera/src/thermo/IonsFromNeutralVPSSTP.cpp @@ -615,9 +615,9 @@ namespace Cantera { // This is temporary. We will get rid of this - void IonsFromNeutralVPSSTP::setTemperature(doublereal t) { + void IonsFromNeutralVPSSTP::setTemperature(const doublereal temp) { double p = pressure(); - IonsFromNeutralVPSSTP::setState_TP(t, p); + IonsFromNeutralVPSSTP::setState_TP(temp, p); } // This is temporary. We will get rid of this diff --git a/Cantera/src/thermo/IonsFromNeutralVPSSTP.h b/Cantera/src/thermo/IonsFromNeutralVPSSTP.h index f9070fa0c..88b05e786 100644 --- a/Cantera/src/thermo/IonsFromNeutralVPSSTP.h +++ b/Cantera/src/thermo/IonsFromNeutralVPSSTP.h @@ -458,7 +458,7 @@ namespace Cantera { * @{ */ - virtual void setTemperature(doublereal t); + virtual void setTemperature(const doublereal t); virtual void setPressure(doublereal p); //! Set the temperature (K) and pressure (Pa) diff --git a/Cantera/src/thermo/SingleSpeciesTP.cpp b/Cantera/src/thermo/SingleSpeciesTP.cpp index 3bdfe52b3..8e8372c47 100644 --- a/Cantera/src/thermo/SingleSpeciesTP.cpp +++ b/Cantera/src/thermo/SingleSpeciesTP.cpp @@ -232,20 +232,29 @@ namespace Cantera { * of the zeroeth species. */ - /** - * Get the array of chemical potentials at unit activity - * These are the standard state chemical potentials. - * \f$ \mu^0_k \f$. + + // Get the array of chemical potentials at unit activity + /* + * These are the standard state chemical potentials. \f$ \mu^0_k \f$. + * + * @param mu On return, Contains the chemical potential of the single species + * and the phase. Units are J / kmol . Length = 1 */ void SingleSpeciesTP::getChemPotentials(doublereal* mu) const { getStandardChemPotentials(mu); } - /** - * Get the array of non-dimensional species chemical potentials - * These are partial molar Gibbs free energies. - * \f$ \mu_k / \hat R T \f$. + + // Get the array of non-dimensional species chemical potentials + // These are partial molar Gibbs free energies. + /* + * These are the standard state dimensionless chemical potentials. + * \f$ \mu_k / \hat R T \f$. + * * Units: unitless + * + * @param murt On return, Contains the chemical potential / RT of the single species + * and the phase. Units are unitless. Length = 1 */ void SingleSpeciesTP::getChemPotentials_RT(doublereal* murt) const { getStandardChemPotentials(murt); @@ -253,21 +262,27 @@ namespace Cantera { murt[0] /= rt; } - /** - * Get the species electrochemical potentials. Units: J/kmol. + // Get the species electrochemical potentials. Units: J/kmol. + /* * This method adds a term \f$ Fz_k \phi_k \f$ to * each chemical potential. * - * This is resolved here. A single single species phase - * is not allowed to have anything other than a zero - * charge. + * This is resolved here. A single species phase + * is not allowed to have anything other than a zero charge. + * + * @param murt On return, Contains the chemical potential / RT of the single species + * and the phase. Units are unitless. Length = 1 */ void SingleSpeciesTP::getElectrochemPotentials(doublereal* mu) const { getChemPotentials(mu); } - /** - * Get the species partial molar enthalpies. Units: J/kmol. + // Get the species partial molar enthalpies. Units: J/kmol. + /* + * These are the phase enthalpies. \f$ h_k \f$. + * + * @param hbar On return, Contains the enthalpy of the single species + * and the phase. Units are J / kmol . Length = 1 */ void SingleSpeciesTP:: getPartialMolarEnthalpies(doublereal* hbar) const { @@ -276,8 +291,15 @@ namespace Cantera { hbar[0] *= _rt; } - /** - * Get the species partial molar internal energies. Units: J/kmol. + // Get the species partial molar internal energies. Units: J/kmol. + /* + * These are the phase internal energies. \f$ u_k \f$. + * + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param ubar On return, Contains the internal energy of the single species + * and the phase. Units are J / kmol . Length = 1 */ void SingleSpeciesTP:: getPartialMolarIntEnergies(doublereal* ubar) const { @@ -286,8 +308,15 @@ namespace Cantera { ubar[0] *= _rt; } - /** - * Get the species partial molar entropy. Units: J/kmol K. + // Get the species partial molar entropy. Units: J/kmol K. + /* + * This is the phase entropy. \f$ s(T,P) = s_o(T,P) \f$. + * + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param sbar On return, Contains the entropy of the single species + * and the phase. Units are J / kmol / K . Length = 1 */ void SingleSpeciesTP:: getPartialMolarEntropies(doublereal* sbar) const { @@ -295,16 +324,30 @@ namespace Cantera { sbar[0] *= GasConstant; } - /** - * Get the species partial molar Heat Capacities. Units: J/kmol K. + // Get the species partial molar Heat Capacities. Units: J/ kmol K. + /* + * This is the phase heat capacity. \f$ Cp(T,P) = Cp_o(T,P) \f$. + * + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param cpbar On return, Contains the heat capacity of the single species + * and the phase. Units are J / kmol / K . Length = 1 */ void SingleSpeciesTP::getPartialMolarCp(doublereal* cpbar) const { getCp_R(cpbar); cpbar[0] *= GasConstant; } - - /** - * Get the species partial molar volumes. Units: m^3/kmol. + + // Get the species partial molar volumes. Units: m^3/kmol. + /* + * This is the phase molar volume. \f$ V(T,P) = V_o(T,P) \f$. + * + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param cpbar On return, Contains the molar volume of the single species + * and the phase. Units are m^3 / kmol. Length = 1 */ void SingleSpeciesTP::getPartialMolarVolumes(doublereal* vbar) const { double mw = molecularWeight(0); @@ -317,7 +360,7 @@ namespace Cantera { * ----- */ - /** + /* * Get the dimensional Gibbs functions for the standard * state of the species at the current T and P. */ @@ -326,14 +369,17 @@ namespace Cantera { gpure[0] *= GasConstant * temperature(); } - /** - * Get the molar volumes of each species in their standard - * states at the current - * T and P of the solution. - * units = m^3 / kmol + + // Get the molar volumes of each species in their standard + // states at the current T and P of the solution. + /* + * units = m^3 / kmol * * We resolve this function at this level, by assigning - * the molec weight divided by the phase density + * the molecular weight divided by the phase density + * + * @param vbar On output this contains the standard volume of the species + * and phase (m^3/kmol). Vector of length 1 */ void SingleSpeciesTP::getStandardVolumes(doublereal* vbar) const { double mw = molecularWeight(0); diff --git a/Cantera/src/thermo/SingleSpeciesTP.h b/Cantera/src/thermo/SingleSpeciesTP.h index 59e726bf2..8375b1eae 100644 --- a/Cantera/src/thermo/SingleSpeciesTP.h +++ b/Cantera/src/thermo/SingleSpeciesTP.h @@ -256,49 +256,47 @@ namespace Cantera { * standard state functions for species 0 */ - /** - * Get the array of non-dimensional species chemical potentials - * These are partial molar Gibbs free energies. - * \f$ \mu_k / \hat R T \f$. + //! Get the array of non-dimensional species chemical potentials + //! These are partial molar Gibbs free energies. + /*! + * These are the phase, partial molar, and the standard state + * dimensionless chemical potentials. + * \f$ \mu_k / \hat R T \f$. + * * Units: unitless * - * This function is resolved here by calling the standard state - * thermo function. - * - * @param mu Output vector of dimensionless chemical potentials. - * Length: m_kk. + * @param murt On return, Contains the chemical potential / RT of the single species + * and the phase. Units are unitless. Length = 1 */ - void getChemPotentials_RT(doublereal* mu) const; + void getChemPotentials_RT(doublereal* murt) const; - /** - * Get the species chemical potentials in the solution - * These are partial molar Gibbs free energies. - * Units: J/kmol. + //! Get the array of chemical potentials + /*! + * These are the phase, partial molar, and the standard state chemical potentials. + * \f$ \mu(T,P) = \mu^0_k(T,P) \f$. * - * This function is resolved here by calling the standard state - * thermo function. - * - * @param mu Output vector of species chemical - * potentials. Length: m_kk. Units: J/kmol + * @param mu On return, Contains the chemical potential of the single species + * and the phase. Units are J / kmol . Length = 1 */ void getChemPotentials(doublereal* mu) const; - /** - * Get the species electrochemical potentials. Units: J/kmol. + //! Get the species electrochemical potentials. Units: J/kmol. + /*! * This method adds a term \f$ Fz_k \phi_k \f$ to * each chemical potential. * - * This is resolved here. A single single species phase - * is not allowed to have anything other than a zero - * charge. + * This is resolved here. A single species phase + * is not allowed to have anything other than a zero charge. * - * @param mu Output vector of species electrochemical - * potentials. Length: m_kk. Units: J/kmol + * @param mu On return, Contains the electrochemical potential of the single species + * and the phase. Units J/kmol . Length = 1 */ void getElectrochemPotentials(doublereal* mu) const; //! Get the species partial molar enthalpies. Units: J/kmol. /*! + * These are the phase enthalpies. \f$ h_k \f$. + * * This function is resolved here by calling the standard state * thermo function. * @@ -307,43 +305,52 @@ namespace Cantera { */ void getPartialMolarEnthalpies(doublereal* hbar) const; - //! Get the species partial molar enthalpies. Units: J/kmol. + + //! Get the species partial molar internal energies. Units: J/kmol. /*! - * This function is resolved here by calling the standard state - * thermo function. + * These are the phase internal energies. \f$ u_k \f$. * - * @param ubar Output vector of speciar partial molar internal energies. - * Length = m_kk. units are J/kmol. + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param ubar On return, Contains the internal energy of the single species + * and the phase. Units are J / kmol . Length = 1 */ virtual void getPartialMolarIntEnergies(doublereal* ubar) const; - //! Get the species partial molar entropies. Units: J/kmol/K. + //! Get the species partial molar entropy. Units: J/kmol K. /*! - * This function is resolved here by calling the standard state - * thermo function. + * This is the phase entropy. \f$ s(T,P) = s_o(T,P) \f$. * - * @param sbar Output vector of species partial molar entropies. - * Length = 1. units are J/kmol/K. + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param sbar On return, Contains the entropy of the single species + * and the phase. Units are J / kmol / K . Length = 1 */ void getPartialMolarEntropies(doublereal* sbar) const; - //! Get the species partial molar heat capacties. Units: J/kmol/K. + //! Get the species partial molar Heat Capacities. Units: J/ kmol /K. /*! - * This function is resolved here by calling the standard state - * thermo function. + * This is the phase heat capacity. \f$ Cp(T,P) = Cp_o(T,P) \f$. * - * @param cpbar Output vector of species partial molar heat capacities - * Length = 1. units are J/kmol/K. + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param cpbar On return, Contains the heat capacity of the single species + * and the phase. Units are J / kmol / K . Length = 1 */ void getPartialMolarCp(doublereal* cpbar) const; - //! Get the species partial molar volumes. Units: m^3/kmol. /*! - * This function is resolved here by calling the density function. + * This is the phase molar volume. \f$ V(T,P) = V_o(T,P) \f$. * - * @param vbar Output vector of speciar partial molar volumes. - * Length = 1. units are m^3/kmol. + * This member function is resolved here. A single species phase obtains its + * thermo from the standard state function. + * + * @param vbar On return, Contains the molar volume of the single species + * and the phase. Units are m^3 / kmol. Length = 1 */ void getPartialMolarVolumes(doublereal* vbar) const; @@ -367,19 +374,18 @@ namespace Cantera { */ void getPureGibbs(doublereal* gpure) 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 + //! Get the molar volumes of each species in their standard + //! states at the current T and P of the solution. + /*! + * units = m^3 / kmol * * We resolve this function at this level, by assigning - * the molec weight divided by the phase density + * the molecular weight divided by the phase density * - * @param vol vector of length one, containing the standard volume - * of the phase. + * @param vbar On output this contains the standard volume of the species + * and phase (m^3/kmol). Vector of length 1 */ - void getStandardVolumes(doublereal *vol) const; + void getStandardVolumes(doublereal *vbar) const; //@} diff --git a/Cantera/src/thermo/VPStandardStateTP.cpp b/Cantera/src/thermo/VPStandardStateTP.cpp index 2c1da45e1..0367dd46d 100644 --- a/Cantera/src/thermo/VPStandardStateTP.cpp +++ b/Cantera/src/thermo/VPStandardStateTP.cpp @@ -357,8 +357,8 @@ namespace Cantera { } - void VPStandardStateTP::setTemperature(doublereal t) { - setState_TP(t, m_Pcurrent); + void VPStandardStateTP::setTemperature(const doublereal temp) { + setState_TP(temp, m_Pcurrent); updateStandardStateThermo(); } diff --git a/Cantera/src/thermo/VPStandardStateTP.h b/Cantera/src/thermo/VPStandardStateTP.h index 4faed6a10..988ac937a 100644 --- a/Cantera/src/thermo/VPStandardStateTP.h +++ b/Cantera/src/thermo/VPStandardStateTP.h @@ -282,9 +282,9 @@ namespace Cantera { * make sense to calculate the standard state without first * setting T and P. * - * @param T Temperature (kelvin) + * @param temp Temperature (kelvin) */ - virtual void setTemperature(const doublereal T); + virtual void setTemperature(const doublereal temp); //! Set the internally storred pressure (Pa) at constant @@ -296,7 +296,7 @@ namespace Cantera { * * @param p input Pressure (Pa) */ - virtual void setPressure(const doublereal p); + virtual void setPressure(doublereal p); protected: /** diff --git a/Cantera/src/thermo/WaterProps.h b/Cantera/src/thermo/WaterProps.h index b6099f7df..a738e20de 100644 --- a/Cantera/src/thermo/WaterProps.h +++ b/Cantera/src/thermo/WaterProps.h @@ -164,7 +164,7 @@ namespace Cantera { * * units = returns density in kg m-3. */ - static double density_T(double T, double P, int ifunc); + static doublereal density_T(doublereal T, doublereal P, int ifunc); //! Bradley-Pitzer equation for the dielectric constant @@ -200,7 +200,7 @@ namespace Cantera { * value at 25C and 1 atm, relEps = 78.38 * */ - double relEpsilon(double T, double P_pascal, int ifunc = 0); + doublereal relEpsilon(doublereal T, doublereal P_pascal, int ifunc = 0); //! ADebye calculates the value of A_Debye as a function @@ -243,7 +243,7 @@ namespace Cantera { * - ifunc = 3 return pressure first derivative * . * - * @return Returns a single double whose meaning depends on ifunc: + * @return Returns a single doublereal whose meaning depends on ifunc: * - ifunc = 0 return value * - ifunc = 1 return temperature derivative * - ifunc = 2 return temperature second derivative @@ -258,7 +258,7 @@ namespace Cantera { * the Pitzer table p. 99 to 4 significant digits at 25C. * and 20C. (Aphi = ADebye/3) */ - double ADebye(double T, double P, int ifunc); + doublereal ADebye(doublereal T, doublereal P, int ifunc); //! Returns the saturation pressure given the temperature @@ -266,7 +266,7 @@ namespace Cantera { * @param T temperature (kelvin) * @return returns the saturation pressure (pascal) */ - double satPressure(double T); + doublereal satPressure(doublereal T); //! Returns the density of water @@ -277,14 +277,14 @@ namespace Cantera { * @param T Temperature (kelvin) * @param P pressure (pascal) */ - double density_IAPWS(double T, double P); + doublereal density_IAPWS(doublereal T, doublereal P); //! Returns the density of water /*! * This function uses the internal state of the * underlying water object */ - double density_IAPWS() const; + doublereal density_IAPWS() const; //! returns the coefficient of thermal expansion @@ -292,14 +292,14 @@ namespace Cantera { * @param T Temperature (kelvin) * @param P pressure (pascal) */ - double coeffThermalExp_IAPWS(double T, double P); + doublereal coeffThermalExp_IAPWS(doublereal T, doublereal P); //! Returns the isothermal compressibility of water /*! * @param T temperature in kelvin * @param P pressure in pascal */ - double isothermalCompressibility_IAPWS(double T, double P); + doublereal isothermalCompressibility_IAPWS(doublereal T, doublereal P); //! Returns the viscosity of water at the current conditions //! (kg/m/s) @@ -316,7 +316,7 @@ namespace Cantera { * for steam and for water, even near the critical point. * Pressures above 500 MPa and temperature above 900 C are suspect. */ - double viscosityWater() const; + doublereal viscosityWater() const; //! Returns the thermal conductivity of water at the current conditions //! (W/m/K) @@ -333,7 +333,7 @@ namespace Cantera { * for steam and for water, even near the critical point. * Pressures above 500 MPa and temperature above 900 C are suspect. */ - double thermalConductivityWater() const; + doublereal thermalConductivityWater() const; diff --git a/tools/doc/Cantera.cfg.in b/tools/doc/Cantera.cfg.in index a93e74080..7631a0397 100755 --- a/tools/doc/Cantera.cfg.in +++ b/tools/doc/Cantera.cfg.in @@ -33,6 +33,12 @@ PROJECT_NAME = Cantera PROJECT_NUMBER = 1.8 +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + + # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location