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

*** empty log message ***

Browse source
This commit is contained in:
Dave Goodwin 2004-02-17 20:05:26 +00:00
parent 80b2acc53a
commit 3b3b97942d
22 changed files with 336 additions and 200 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cantera/src/ConstDensityThermo.h
View file

@ -19,6 +19,7 @@
#include "mix_defs.h"
#include "ThermoPhase.h"
#include "SpeciesThermo.h"
#include "utilities.h"
namespace Cantera {

2
Cantera/src/Elements.cpp
View file

@ -22,12 +22,14 @@
#include "Elements.h"
#include "xml.h"
#include "ctexceptions.h"
#ifdef USE_DGG_CODE
#include <map>
#endif
namespace Cantera {
/* awData structure */
/**

36
Cantera/src/Elements.h
View file

@ -18,30 +18,12 @@
#undef USE_DGG_CODE
#include "ct_defs.h"
#include "ctexceptions.h"
//#include "ctexceptions.h"
namespace Cantera {
class XML_Node;
#ifdef INCL_DEPRECATED_METHODS
/**
* Holds element name and atomic weight. Used for output of
* element properties and initial initialization only.
*/
struct ElementData {
string name;
doublereal atomicWeight;
};
#endif
class ElementRangeError : public CanteraError {
public:
ElementRangeError(string func, int m, int mmax) :
CanteraError(func, "Element index " + int2str(m) +
" outside valid range of 0 to " + int2str(mmax-1)) {}
};
class ElementRangeError;
/** Elements Class: Object contains the elements that make up species.
*
@ -78,11 +60,6 @@ namespace Cantera {
*/
int nElements() const { return m_mm; }
#ifdef INCL_DEPRECATED_METHODS
/// Returns an ElementData struct that contains the parameters
/// for element m.
ElementData element(int m) const;
#endif
/** Function that returns the index of an element.
*
* Index of element named \c name. The index is an integer
@ -179,14 +156,7 @@ namespace Cantera {
* Note, a string search is the primary way to identify elements.
*/
vector<string> m_elementNames;
#ifdef USE_DGG_CODE
/**
* Map of elements to indecises
*
* NOTE: this is redundent
*/
map<string, int> m_definedElements;
#endif
/**
* Number of Constituents Objects that use this object
*

8
Cantera/src/GasKinetics.cpp
View file

@ -677,11 +677,3 @@ namespace Cantera {
}
}

1
Cantera/src/IdealGasPhase.h
View file

@ -20,6 +20,7 @@
#include "mix_defs.h"
#include "ThermoPhase.h"
#include "SpeciesThermo.h"
#include "utilities.h"
namespace Cantera {

162
Cantera/src/InterfaceKinetics.cpp
View file

@ -46,7 +46,8 @@ namespace Cantera {
m_nrev(0),
m_surf(0),
m_integrator(0),
m_finalized(false)
m_finalized(false),
m_has_coverage_dependence(false)
{
m_kdata = new InterfaceKineticsData;
m_kdata->m_temp = 0.0;
@ -69,6 +70,11 @@ namespace Cantera {
void InterfaceKinetics::
_update_rates_T() {
_update_rates_phi();
if (m_has_coverage_dependence) {
m_surf->getCoverages(m_conc.begin());
m_rates.update_C(m_conc.begin());
m_redo_rates = true;
}
doublereal T = thermo(surfacePhaseIndex()).temperature();
if (T != m_kdata->m_temp || m_redo_rates) {
m_kdata->m_logtemp = log(T);
@ -104,16 +110,6 @@ namespace Cantera {
_update_rates_C() {
int n;
/**
* First evaluate the coverage-dependent terms in the reaction
* rates.
*/
// UNCOMMENT and fix
//m_surf->getCoverages(m_conc.begin());
//m_rates.update_C(m_conc.begin());
//m_rates.update(m_kdata->m_temp,
// m_kdata->m_logtemp, m_kdata->m_rfn.begin());
int np = nPhases();
for (n = 0; n < np; n++) {
/*
@ -159,8 +155,9 @@ namespace Cantera {
}
// compute Delta mu^0 for all reversible reactions
m_reactantStoich.decrementReactions(m_mu0.begin(), m_rkc.begin());
m_revProductStoich.incrementReactions(m_mu0.begin(), m_rkc.begin());
//m_reactantStoich.decrementReactions(m_mu0.begin(), m_rkc.begin());
//m_revProductStoich.incrementReactions(m_mu0.begin(), m_rkc.begin());
m_rxnstoich.getRevReactionDelta(m_ii, m_mu0.begin(), m_rkc.begin());
for (i = 0; i < m_nrev; i++) {
irxn = m_revindex[i];
@ -183,8 +180,8 @@ namespace Cantera {
if (m_nrev > 0) {
int n, nsp, k, ik=0;
doublereal rt = GasConstant*thermo(0).temperature();
doublereal rrt = 1.0/rt;
//doublereal rt = GasConstant*thermo(0).temperature();
// doublereal rrt = 1.0/rt;
int np = nPhases();
for (n = 0; n < np; n++) {
thermo(n).getChemPotentials(dmu.begin() + m_start[n]);
@ -197,8 +194,9 @@ namespace Cantera {
}
// compute Delta mu^ for all reversible reactions
m_reactantStoich.decrementReactions(dmu.begin(), rmu.begin());
m_revProductStoich.incrementReactions(dmu.begin(), rmu.begin());
//m_reactantStoich.decrementReactions(dmu.begin(), rmu.begin());
//m_revProductStoich.incrementReactions(dmu.begin(), rmu.begin());
m_rxnstoich.getRevReactionDelta(m_ii, dmu.begin(), rmu.begin());
for (i = 0; i < m_nrev; i++) {
irxn = m_revindex[i];
@ -231,9 +229,10 @@ namespace Cantera {
fill(kc, kc + m_ii, 0.0);
m_reactantStoich.decrementReactions(m_mu0.begin(), kc);
m_revProductStoich.incrementReactions(m_mu0.begin(), kc);
m_irrevProductStoich.incrementReactions(m_mu0.begin(), kc);
//m_reactantStoich.decrementReactions(m_mu0.begin(), kc);
//m_revProductStoich.incrementReactions(m_mu0.begin(), kc);
//m_irrevProductStoich.incrementReactions(m_mu0.begin(), kc);
m_rxnstoich.getReactionDelta(m_ii, m_mu0.begin(), kc);
for (i = 0; i < m_ii; i++) {
kc[i] = exp(-kc[i]*rrt);
@ -266,10 +265,11 @@ namespace Cantera {
// compute the change in electrical potential energy for each
// reaction. This will only be non-zero if a potential
// difference is present.
fill(m_rwork.begin(), m_rwork.begin() + m_ii, 0.0);
m_reactantStoich.decrementReactions(m_pot.begin(), m_rwork.begin());
m_revProductStoich.incrementReactions(m_pot.begin(), m_rwork.begin());
m_irrevProductStoich.incrementReactions(m_pot.begin(), m_rwork.begin());
//fill(m_rwork.begin(), m_rwork.begin() + m_ii, 0.0);
//m_reactantStoich.decrementReactions(m_pot.begin(), m_rwork.begin());
//m_revProductStoich.incrementReactions(m_pot.begin(), m_rwork.begin());
//m_irrevProductStoich.incrementReactions(m_pot.begin(), m_rwork.begin());
m_rxnstoich.getReactionDelta(m_ii, m_pot.begin(), m_rwork.begin());
// modify the reaction rates. Only modify those with a
// non-zero activation energy, and do not decrease the
@ -355,14 +355,16 @@ namespace Cantera {
multiply_each(ropr.begin(), ropr.end(), m_rkc.begin());
// multiply ropf by concentration products
m_reactantStoich.multiply(m_conc.begin(), ropf.begin());
m_rxnstoich.multiplyReactants(m_conc.begin(), ropf.begin());
//m_reactantStoich.multiply(m_conc.begin(), ropf.begin());
// for reversible reactions, multiply ropr by concentration
// products
m_revProductStoich.multiply(m_conc.begin(), ropr.begin());
m_rxnstoich.multiplyRevProducts(m_conc.begin(), ropr.begin());
//m_revProductStoich.multiply(m_conc.begin(), ropr.begin());
// do global reactions
m_globalReactantStoich.power(m_conc.begin(), ropf.begin());
//m_globalReactantStoich.power(m_conc.begin(), ropf.begin());
for (int j = 0; j != m_ii; ++j) {
ropnet[j] = ropf[j] - ropr[j];
@ -388,21 +390,37 @@ namespace Cantera {
void InterfaceKinetics::
addReaction(const ReactionData& r) {
int nr = r.reactants.size();
// int nr = r.reactants.size();
// a global reaction is idnetified as one with
// a global reaction is identified as one with
// a reactant stoichiometric coefficient not equal
// to the molecularity for some reactant
bool isglobal = false;
for (int n = 0; n < nr; n++) {
if (r.rstoich[n] != int(r.order[n])) {
isglobal = true; break;
}
}
if (isglobal)
addGlobalReaction(r);
else
addElementaryReaction(r);
// bool isglobal = false;
// for (int n = 0; n < nr; n++) {
// if (r.rstoich[n] != int(r.order[n])) {
// isglobal = true; break;
// }
// }
// if (isglobal)
// addGlobalReaction(r);
//else
// if (r.global)
// cout << r.equation << " is global " << endl;
addElementaryReaction(r);
//if (r.global) {
// int nr = r.order.size();
// vector_fp ordr(nr);
// for (int n = 0; n < nr; n++) {
// ordr[n] = r.order[n] - r.rstoich[n];
// cout << r.reactants[n] << " " << r.order[n] << " " << ordr[n] << endl;
// }
//m_globalReactantStoich.add( reactionNumber(),
// r.reactants, ordr);
//}
// if (r.reactionType == ELEMENTARY_RXN)
// addElementaryReaction(r);
@ -425,6 +443,9 @@ namespace Cantera {
// install rate coeff calculator
vector_fp rp = r.rateCoeffParameters;
int ncov = r.cov.size();
if (ncov > 3) {
m_has_coverage_dependence = true;
}
for (int m = 0; m < ncov; m++) rp.push_back(r.cov[m]);
iloc = m_rates.install( reactionNumber(),
r.rateCoeffType, rp.size(),
@ -437,31 +458,32 @@ namespace Cantera {
}
void InterfaceKinetics::
addGlobalReaction(const ReactionData& r) {
// void InterfaceKinetics::
// addGlobalReaction(const ReactionData& r) {
int iloc;
// install rate coeff calculator
vector_fp rp = r.rateCoeffParameters;
int ncov = r.cov.size();
for (int m = 0; m < ncov; m++) rp.push_back(r.cov[m]);
iloc = m_rates.install( reactionNumber(),
r.rateCoeffType, rp.size(),
rp.begin() );
// int iloc;
// // install rate coeff calculator
// vector_fp rp = r.rateCoeffParameters;
// int ncov = r.cov.size();
// for (int m = 0; m < ncov; m++) rp.push_back(r.cov[m]);
// iloc = m_rates.install( reactionNumber(),
// r.rateCoeffType, rp.size(),
// rp.begin() );
// // store activation energy
// m_E.push_back(r.rateCoeffParameters[2]);
// // add constant term to rate coeff value vector
// m_kdata->m_rfn.push_back(r.rateCoeffParameters[0]);
// add constant term to rate coeff value vector
m_kdata->m_rfn.push_back(r.rateCoeffParameters[0]);
// int nr = r.order.size();
// vector_fp ordr(nr);
// for (int n = 0; n < nr; n++) {
// ordr[n] = r.order[n] - r.rstoich[n];
// }
// m_globalReactantStoich.add( reactionNumber(),
// r.reactants, ordr);
int nr = r.order.size();
vector_fp ordr(nr);
for (int n = 0; n < nr; n++) {
ordr[n] = r.order[n] - r.rstoich[n];
}
m_globalReactantStoich.add( reactionNumber(),
r.reactants, ordr);
registerReaction( reactionNumber(), GLOBAL_RXN, iloc);
}
// registerReaction( reactionNumber(), GLOBAL_RXN, iloc);
// }
void InterfaceKinetics::installReagents(const ReactionData& r) {
@ -473,6 +495,16 @@ namespace Cantera {
int rnum = reactionNumber();
// vectors rk and pk are lists of species numbers, with
// repeated entries for species with stoichiometric
// coefficients > 1. This allows the reaction to be defined
// with unity reaction order for each reactant, and so the
// faster method 'multiply' can be used to compute the rate of
// progress instead of 'power'.
// Note that this procedure is used for global reactions also.
// The
vector_int rk;
int nr = r.reactants.size();
for (n = 0; n < nr; n++) {
@ -497,15 +529,17 @@ namespace Cantera {
m_kdata->m_rkcn.push_back(0.0);
m_reactantStoich.add( reactionNumber(), rk);
m_rxnstoich.add( reactionNumber(), r);
//m_reactantStoich.add( reactionNumber(), rk);
if (r.reversible) {
m_revProductStoich.add(reactionNumber(), pk);
// m_revProductStoich.add(reactionNumber(), pk);
m_revindex.push_back(reactionNumber());
m_nrev++;
}
else {
m_irrevProductStoich.add(reactionNumber(), pk);
//m_irrevProductStoich.add(reactionNumber(), pk);
m_irrev.push_back( reactionNumber() );
m_nirrev++;
}

56
Cantera/src/InterfaceKinetics.h
View file

@ -22,7 +22,8 @@
#include "utilities.h"
#include "RateCoeffMgr.h"
#include "StoichManager.h"
#include "ReactionStoichMgr.h"
//#include "StoichManager.h"
namespace Cantera {
@ -165,13 +166,15 @@ namespace Cantera {
*/
virtual void getCreationRates(doublereal* cdot) {
updateROP();
fill(cdot, cdot + m_kk, 0.0);
m_revProductStoich.incrementSpecies(
m_kdata->m_ropf.begin(), cdot);
m_irrevProductStoich.incrementSpecies(
m_kdata->m_ropf.begin(), cdot);
m_reactantStoich.incrementSpecies(
m_kdata->m_ropr.begin(), cdot);
m_rxnstoich.getCreationRates(m_kk, m_kdata->m_ropf.begin(),
m_kdata->m_ropr.begin(), cdot);
//fill(cdot, cdot + m_kk, 0.0);
//m_revProductStoich.incrementSpecies(
// m_kdata->m_ropf.begin(), cdot);
//m_irrevProductStoich.incrementSpecies(
// m_kdata->m_ropf.begin(), cdot);
//m_reactantStoich.incrementSpecies(
// m_kdata->m_ropr.begin(), cdot);
}
/**
@ -184,11 +187,13 @@ namespace Cantera {
*/
virtual void getDestructionRates(doublereal* ddot) {
updateROP();
fill(ddot, ddot + m_kk, 0.0);
m_revProductStoich.incrementSpecies(
m_kdata->m_ropr.begin(), ddot);
m_reactantStoich.incrementSpecies(
m_kdata->m_ropf.begin(), ddot);
m_rxnstoich.getDestructionRates(m_kk, m_kdata->m_ropf.begin(),
m_kdata->m_ropr.begin(), ddot);
// fill(ddot, ddot + m_kk, 0.0);
//m_revProductStoich.incrementSpecies(
// m_kdata->m_ropr.begin(), ddot);
//m_reactantStoich.incrementSpecies(
// m_kdata->m_ropf.begin(), ddot);
}
/**
@ -200,13 +205,14 @@ namespace Cantera {
*/
virtual void getNetProductionRates(doublereal* net) {
updateROP();
fill(net, net + m_kk, 0.0);
m_revProductStoich.incrementSpecies(
m_kdata->m_ropnet.begin(), net);
m_irrevProductStoich.incrementSpecies(
m_kdata->m_ropnet.begin(), net);
m_reactantStoich.decrementSpecies(
m_kdata->m_ropnet.begin(), net);
//fill(net, net + m_kk, 0.0);
//m_revProductStoich.incrementSpecies(
// m_kdata->m_ropnet.begin(), net);
//m_irrevProductStoich.incrementSpecies(
// m_kdata->m_ropnet.begin(), net);
//m_reactantStoich.decrementSpecies(
// m_kdata->m_ropnet.begin(), net);
m_rxnstoich.getNetProductionRates(m_kk, m_kdata->m_ropnet.begin(), net);
}
//@}
@ -331,11 +337,12 @@ namespace Cantera {
vector<int> m_irrev;
StoichManagerN m_reactantStoich;
StoichManagerN m_revProductStoich;
StoichManagerN m_irrevProductStoich;
// StoichManagerN m_reactantStoich;
//StoichManagerN m_revProductStoich;
//StoichManagerN m_irrevProductStoich;
StoichManagerN m_globalReactantStoich;
//StoichManagerN m_globalReactantStoich;
ReactionStoichMgr m_rxnstoich;
int m_nirrev;
@ -401,6 +408,7 @@ namespace Cantera {
}
void applyButlerVolmerCorrection(doublereal* kf);
bool m_finalized;
bool m_has_coverage_dependence;
};
}

2
Cantera/src/Phase.cpp
View file

@ -23,7 +23,7 @@ namespace Cantera {
void Phase::saveState(int lenstate, doublereal* state) const {
state[0] = temperature();
state[1] = density();
getMassFractions(lenstate - 2, state + 2);
getMassFractions(state + 2);
}
void Phase::restoreState(vector_fp& state) {

2
Cantera/src/ReactionData.h
View file

@ -33,6 +33,7 @@ namespace Cantera {
error = 0;
equation = "";
default_3b_eff = 1.0;
global = false;
}
~ReactionData(){}
@ -56,6 +57,7 @@ namespace Cantera {
string equation;
doublereal default_3b_eff;
vector_fp cov;
bool global;
};
}

122
Cantera/src/ReactionStoichMgr.cpp
View file

@ -1,3 +1,14 @@
//------------------------------------------------
///
/// @file ReactionStoichMgr.cpp
///
///
//------------------------------------------------
// $Author$
// $Revision$
// $Date$
// turn off warnings under Windows
#ifdef WIN32
#pragma warning(disable:4786)
@ -7,6 +18,9 @@
#include "ReactionStoichMgr.h"
#include "StoichManager.h"
#include "ctexceptions.h"
#include "diagnostics.h"
#include "ReactionData.h"
namespace Cantera {
@ -18,6 +32,7 @@ namespace Cantera {
m_reactants = new StoichManagerN;
m_revproducts = new StoichManagerN;
m_irrevproducts = new StoichManagerN;
m_global = new StoichManagerN;
}
// delete the three stoichiometry managers
@ -25,37 +40,115 @@ namespace Cantera {
delete m_reactants;
delete m_revproducts;
delete m_irrevproducts;
delete m_global;
}
void ReactionStoichMgr::
add(int rxn, const vector_int& reactants, const vector_int& products,
bool reversible) {
vector_fp forder(reactants.size(), 1.0);
add(rxn, reactants, products, reversible, forder);
}
m_reactants->add(rxn, reactants);
void ReactionStoichMgr::
add(int rxn, const vector_int& reactants, const vector_int& products,
bool reversible, const vector_fp& fwdOrder) {
// add the reactants with the specified forward order
m_reactants->add(rxn, reactants, fwdOrder);
// depending on whether the reversible flag is set or not, add the
// products either to the reversible or irreversible product
// stoichiometry manager.
if (reversible)
m_revproducts->add(rxn, products);
else
m_irrevproducts->add(rxn, products);
}
void ReactionStoichMgr::
add(int rxn, const ReactionData& r) {
vector_int rk;
int n, ns, m, nr = r.reactants.size();
for (n = 0; n < nr; n++) {
ns = r.rstoich[n];
// m_rrxn[r.reactants[n]][rnum] = ns;
for (m = 0; m < ns; m++) {
rk.push_back(r.reactants[n]);
}
}
vector_int pk;
int np = r.products.size();
for (n = 0; n < np; n++) {
ns = r.pstoich[n];
// m_prxn[r.products[n]][rnum] = ns;
for (m = 0; m < ns; m++) {
pk.push_back(r.products[n]);
}
}
m_reactants->add( rxn, rk);
if (r.reversible) {
m_revproducts->add(rxn, pk);
}
else {
m_irrevproducts->add(rxn, pk);
}
if (r.global) {
vector_fp delta_order(nr,0.0);
for (n = 0; n < nr; n++) {
delta_order[n] = r.order[n] - r.rstoich[n];
cout << "rxn stoich " << r.reactants[n] << " " << r.order[n] << " " << delta_order[n] << endl;
}
m_global->add(rxn, r.reactants, delta_order);
}
}
// void ReactionStoichMgr::
// add(int rxn, const vector_int& reactants, const vector_int& products,
// bool reversible, const vector_fp& fwdOrder) {
// #ifdef DIAGNOSE_RXNSTOICHMGR
// printf("ReactionStoichMgr::add adding reaction number %d\n", rxn);
// #endif
// // add the reactants with the specified forward order
// m_reactants->add(rxn, reactants, fwdOrder);
// // check whether any orders are not equal to 1.0
// // if so, add an entry to the global stoich manager
// // with orders decremented by one
// int nr = reactants.size();
// int n;
// bool global = false;
// for (n = 0; n < nr; n++) {
// if (fwdOrder[n] != 1.0) {
// #ifdef DIAGNOSE_RXNSTOICHMGR
// printf(".... global reaction: fwdOrder[%d] = %f.\n", n, fwdOrder[n]);
// #endif
// global = true;
// if (reversible) {
// throw CanteraError("ReactionStoichMgr::add",
// "reversible global reactions not allowed");
// }
// }
// }
// if (global) {
// vector_fp fwdOrder_minus_one;
// for (n = 0; n < nr; n++)
// fwdOrder_minus_one[n] = fwdOrder[n] - 1.0;
// m_global->add(rxn, reactants, fwdOrder_minus_one);
// }
// // depending on whether the reversible flag is set or not, add the
// // products either to the reversible or irreversible product
// // stoichiometry manager.
// if (reversible)
// m_revproducts->add(rxn, products);
// else
// m_irrevproducts->add(rxn, products);
// }
void ReactionStoichMgr::
getCreationRates(int nsp, const doublereal* ropf, const doublereal* ropr, doublereal* c) {
// zero out the target array
fill(c, c + nsp, 0.0);
m_revproducts->incrementSpecies(ropf, c);
m_irrevproducts->incrementSpecies(ropf, c);
@ -95,6 +188,7 @@ namespace Cantera {
void ReactionStoichMgr::
multiplyReactants(const doublereal* c, doublereal* r) {
m_reactants->multiply(c, r);
m_global->power(c, r);
}
void ReactionStoichMgr::

14
Cantera/src/ReactionStoichMgr.h
View file

@ -18,6 +18,7 @@
namespace Cantera {
class StoichManagerN;
class ReactionData;
/**
* Reaction mechanism stoichiometry manager. This is an internal class used
@ -110,11 +111,11 @@ namespace Cantera {
* species with index in the corresponding location in 'reactants.'
*
*/
void add(int rxn, const vector_int& reactants, const vector_int& products,
bool reversible, const vector_fp& fwdOrder);
// void add(int rxn, const vector_int& reactants, const vector_int& products,
// bool reversible, const vector_fp& fwdOrder);
void add(int rxn, const ReactionData& r);
/**
* Species creation rates.
@ -219,9 +220,10 @@ namespace Cantera {
protected:
StoichManagerN* m_reactants;
StoichManagerN* m_revproducts;
StoichManagerN* m_irrevproducts;
StoichManagerN* m_reactants;
StoichManagerN* m_revproducts;
StoichManagerN* m_irrevproducts;
StoichManagerN* m_global;
};
}

20
Cantera/src/State.cpp
View file

@ -116,6 +116,26 @@ namespace Cantera {
}
}
void State::getConcentrations(doublereal* c) const {
scale(m_ym.begin(), m_ym.end(), c, m_dens);
}
doublereal State::mean_X(const doublereal* Q) const {
return m_mmw*dot(m_ym.begin(), m_ym.end(), Q);
}
doublereal State::mean_Y(const doublereal* Q) const {
return dot(m_ym.begin(), m_ym.end(), Q);
}
void State::getMoleFractions(doublereal* x) const {
scale(m_ym.begin(), m_ym.end(), x, m_mmw);
}
void State::getMassFractions(doublereal* y) const {
copy(m_y.begin(), m_y.end(), y);
}
void State::init(const array_fp& mw) {
m_kk = mw.size();
m_molwts.resize(m_kk);

37
Cantera/src/State.h
View file

@ -19,8 +19,9 @@
#ifndef CT_STATE2_H
#define CT_STATE2_H
#include "utilities.h"
#include "ctexceptions.h"
#include "ct_defs.h"
//#include "utilities.h"
//#include "ctexceptions.h"
namespace Cantera {
@ -62,9 +63,7 @@ namespace Cantera {
* @param x On return, x contains the mole fractions. Must have a
* length greater than or equal to the number of species.
*/
void getMoleFractions(doublereal* x) const {
scale(m_ym.begin(), m_ym.end(), x, m_mmw);
}
void getMoleFractions(doublereal* x) const;
/// The mole fraction of species k.
doublereal moleFraction(int k) const;
@ -89,18 +88,16 @@ namespace Cantera {
* @param y On return, y contains the mass fractions. Array y
* must have a length at least as large as the number of species.
*/
void getMassFractions(size_t leny, doublereal* y) const {
copy(m_y.begin(), m_y.end(), y);
}
//void getMassFractions(size_t leny, doublereal* y) const {
// copy(m_y.begin(), m_y.end(), y);
//}
/**
* Get the species mass fractions. @param y On return, y
* contains the mass fractions. Array \i y must have a length
* greater than or equal to the number of species.
*/
void getMassFractions(doublereal* y) const {
copy(m_y.begin(), m_y.end(), y);
}
void getMassFractions(doublereal* y) const;
/// Mass fraction of species k.
doublereal massFraction(int k) const;
@ -127,10 +124,7 @@ namespace Cantera {
* Array \i c must have a length greater than or equal to
* the number of species.
*/
void getConcentrations(doublereal* c) const {
doublereal f = m_dens;
scale(m_ym.begin(), m_ym.end(), c, f);
}
void getConcentrations(doublereal* c) const;
/**
* Evaluate the mole-fraction-weighted mean of Q:
@ -138,10 +132,7 @@ namespace Cantera {
* Array Q should contain pure-species molar property
* values.
*/
doublereal mean_X(const doublereal* Q) const {
return m_mmw*dot(m_ym.begin(), m_ym.end(), Q);
}
doublereal mean_X(const doublereal* Q) const;
/**
* Evaluate the mass-fraction-weighted mean of Q:
@ -149,9 +140,7 @@ namespace Cantera {
* Array Q should contain pure-species property
* values in mass units.
*/
doublereal mean_Y(const doublereal* Q) const {
return dot(m_y.begin(), m_y.end(), Q);
}
doublereal mean_Y(const doublereal* Q) const;
/**
* The mean molecular weight. Units: (kg/kmol)
@ -179,10 +168,10 @@ namespace Cantera {
/// Set the density to value rho (kg/m^3).
void setDensity(doublereal rho) {
if (rho != m_dens) {
// if (rho != m_dens) {
m_dens = rho;
//m_C_updater.need_update();
}
//}
}
/// Set the molar density to value n (kmol/m^3).

6
Cantera/src/SurfPhase.cpp
View file

@ -14,6 +14,7 @@
#include "SurfPhase.h"
#include "EdgePhase.h"
#include "utilities.h"
#include <iostream>
using namespace std;
@ -225,19 +226,18 @@ namespace Cantera {
m_tlast = tnow;
doublereal rt = GasConstant * tnow;
int k;
//doublereal deltaE;
for (k = 0; k < m_kk; k++) {
m_h0[k] *= rt;
m_s0[k] *= GasConstant;
m_cp0[k] *= GasConstant;
//deltaE = m_pe[k];
//m_h0[k] += deltaE;
m_mu0[k] = m_h0[k] - tnow*m_s0[k];
}
m_tlast = tnow;
}
}
EdgePhase::EdgePhase(doublereal n0) : SurfPhase(n0) {
setNDim(1);
}

7
Cantera/src/ThermoPhase.cpp
View file

@ -23,6 +23,13 @@
namespace Cantera {
void ThermoPhase::getActivities(doublereal* a) {
getActivityConcentrations(a);
int nsp = nSpecies();
int k;
for (k = 0; k < nsp; k++) a[k] /= standardConcentration(k);
}
void ThermoPhase::setState_TPX(doublereal t, doublereal p,
const doublereal* x) {
setMoleFractions(x); setTemperature(t); setPressure(p);

7
Cantera/src/ThermoPhase.h
View file

@ -550,12 +550,7 @@ namespace Cantera {
}
//@}
void getActivities(doublereal* a) {
getActivityConcentrations(a);
int nsp = nSpecies();
doublereal rc = 1.0/standardConcentration();
scale(a, a + nsp, a, rc);
}
void getActivities(doublereal* a);
/**

25
Cantera/src/ctexceptions.h
View file

@ -24,17 +24,17 @@ namespace Cantera {
CanteraError() {}
CanteraError(string proc, string msg) {
setError(proc, msg);
m_msg = msg;
//m_msg = msg;
}
virtual ~CanteraError(){}
string errorMessage() { return m_msg; }
void append(string msg) { m_msg += msg; }
void saveError(string procedure) {
setError(procedure, m_msg);
m_msg = "";
}
//string errorMessage() { return m_msg; }
//void append(string msg) { m_msg += msg; }
//void saveError(string procedure) {
// setError(procedure, m_msg);
// m_msg = "";
//}
protected:
string m_msg;
//string m_msg;
};
class ArraySizeError : public CanteraError {
@ -42,6 +42,15 @@ namespace Cantera {
ArraySizeError(string proc, int sz, int reqd) :
CanteraError(proc, "Array size ("+int2str(sz)+") too small. Must be at least "+int2str(reqd)) {}
};
class ElementRangeError : public CanteraError {
public:
ElementRangeError(string func, int m, int mmax) :
CanteraError(func, "Element index " + int2str(m) +
" outside valid range of 0 to " + int2str(mmax-1)) {}
};
}
#endif

10
Cantera/src/diagnostics.h Normal file
View file

@ -0,0 +1,10 @@
#ifndef CT_DIAGNOSTICS_H
#define CT_DIAGNOSTICS_H
#ifdef DIAGNOSE_ALL
#define DIAGNOSE_RXNSTOICHMGR // ReactionStoichMgr
#endif
#endif

2
Cantera/src/importCTML.cpp
View file

@ -1146,7 +1146,7 @@ next:
throw CanteraError("installReaction",
"reaction orders may only be given for "
"irreversible reactions");
//typ = "global";
rdata.global = true;
}

12
Cantera/src/oneD/StFlow.cpp
View file

@ -64,7 +64,7 @@ namespace Cantera {
// copy mass fractions
int nsp0 = oldmech.nSpecies();
int nsp1 = newmech.nSpecies();
//int nsp1 = newmech.nSpecies();
// loop over the species in the old mechanism
for (int k = 0; k < nsp0; k++) {
@ -86,17 +86,17 @@ namespace Cantera {
// normalize mass fractions
for (j = 0; j < points; j++) {
newmech.setMassFractions(&newSoln[nv_new*j + 4]);
newmech.getMassFractions(nsp1,&newSoln[nv_new*j + 4]);
newmech.getMassFractions(&newSoln[nv_new*j + 4]);
}
}
//---------------------- drawline ----------------------------------
static void drawline(ostream& s) {
s << "\n-------------------------------------"
<< "------------------------------------------";
}
//static void drawline(ostream& s) {
// s << "\n-------------------------------------"
// << "------------------------------------------";
//}
static void drawline() {
writelog("\n-------------------------------------"

2
Cantera/src/oneD/boundaries1D.cpp
View file

@ -638,7 +638,7 @@ namespace Cantera {
//scale(m_work.begin(), m_work.end(), m_work.begin(), m_mult[0]);
bool enabled = true;
// bool enabled = true;
int ioffset = m_kin->kineticsSpeciesIndex(0, m_surfindex);
if (m_enabled) {

2
Cantera/src/zeroD/Reactor.cpp
View file

@ -68,7 +68,7 @@ namespace Cantera {
// set components y + 2 ... y + K + 1 to the
// mass M_k of each species
m_mix->getMassFractions(leny-2, y+2);
m_mix->getMassFractions(y+2);
scale(y + 2, y + m_nsp + 2, y + 2, mass);
// set the first component to the total internal