392 lines
11 KiB
C++
392 lines
11 KiB
C++
/**
|
|
* @file EdgeKinetics.h
|
|
*
|
|
* $Author$
|
|
* $Revision$
|
|
* $Date$
|
|
*/
|
|
|
|
// Copyright 2001 California Institute of Technology
|
|
|
|
|
|
#ifndef CT_EDGEKINETICS_H
|
|
#define CT_EDGEKINETICS_H
|
|
|
|
#include <fstream>
|
|
#include <math.h>
|
|
#include <map>
|
|
#include <stdlib.h>
|
|
|
|
#include "mix_defs.h"
|
|
#include "Kinetics.h"
|
|
|
|
#include "utilities.h"
|
|
#include "RateCoeffMgr.h"
|
|
#include "StoichManager.h"
|
|
|
|
namespace Cantera {
|
|
|
|
// forward references
|
|
|
|
class ReactionData;
|
|
class EdgeKineticsData;
|
|
class ThermoPhase;
|
|
class SurfPhase;
|
|
class ImplicitSurfChem;
|
|
|
|
/**
|
|
* Holds mechanism-specific data.
|
|
*/
|
|
class EdgeKineticsData {
|
|
public:
|
|
EdgeKineticsData() :
|
|
m_ROP_ok(false),
|
|
m_temp(0.0), m_logtemp(0.0)
|
|
{}
|
|
virtual ~EdgeKineticsData(){}
|
|
|
|
doublereal m_logp0, m_logc0;
|
|
array_fp m_ropf, m_ropr, m_ropnet;
|
|
//array_fp m_rfn_low, m_rfn_high;
|
|
bool m_ROP_ok;
|
|
|
|
doublereal m_temp, m_logtemp;
|
|
vector_fp m_rfn;
|
|
vector_fp m_rkcn;
|
|
};
|
|
|
|
|
|
class EdgeKinetics : public Kinetics {
|
|
|
|
public:
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
*/
|
|
EdgeKinetics();
|
|
|
|
/// Destructor.
|
|
virtual ~EdgeKinetics();
|
|
|
|
/**
|
|
* Identifies the subclass of the Kinetics manager type.
|
|
* These are listed in mix_defs.h.
|
|
*/
|
|
virtual int ID() { return cEdgeKinetics; }
|
|
|
|
/**
|
|
* Identifies the subclass of the Kinetics manager type.
|
|
* These are listed in mix_defs.h.
|
|
*/
|
|
virtual int type() { return cEdgeKinetics; }
|
|
|
|
/**
|
|
* Set the electric potential in the nth phase
|
|
*
|
|
* @param n phase Index in this kinetics object.
|
|
* @param V Electric potential (volts)
|
|
*/
|
|
void setElectricPotential(int n, doublereal V) {
|
|
thermo(n).setElectricPotential(V);
|
|
m_redo_rates = true;
|
|
}
|
|
|
|
/**
|
|
* @name Reaction Rates Of Progress
|
|
*/
|
|
//@{
|
|
|
|
/**
|
|
* Forward rates of progress.
|
|
* Return the forward rates of progress in array fwdROP, which
|
|
* must be dimensioned at least as large as the total number
|
|
* of reactions.
|
|
* Units are kmol/m2/s
|
|
*/
|
|
virtual void getFwdRatesOfProgress(doublereal* fwdROP) {
|
|
updateROP();
|
|
copy(m_kdata->m_ropf.begin(), m_kdata->m_ropf.end(), fwdROP);
|
|
}
|
|
|
|
/**
|
|
* Reverse rates of progress.
|
|
* Return the reverse rates of progress in array revROP, which
|
|
* must be dimensioned at least as large as the total number
|
|
* of reactions.
|
|
* Units are kmol/m2/s
|
|
*/
|
|
virtual void getRevRatesOfProgress(doublereal* revROP) {
|
|
updateROP();
|
|
copy(m_kdata->m_ropr.begin(), m_kdata->m_ropr.end(), revROP);
|
|
}
|
|
|
|
/**
|
|
* Net rates of progress. Return the net (forward - reverse)
|
|
* rates of progress in array netROP, which must be
|
|
* dimensioned at least as large as the total number of
|
|
* reactions.
|
|
* Units are kmol/m2/s
|
|
*/
|
|
virtual void getNetRatesOfProgress(doublereal* netROP) {
|
|
updateROP();
|
|
copy(m_kdata->m_ropnet.begin(), m_kdata->m_ropnet.end(), netROP);
|
|
}
|
|
|
|
/**
|
|
* Equilibrium constants. Return the equilibrium constants of
|
|
* the reactions in concentration units in array kc, which
|
|
* must be dimensioned at least as large as the total number
|
|
* of reactions.
|
|
*/
|
|
virtual void getEquilibriumConstants(doublereal* kc);
|
|
|
|
|
|
//@}
|
|
/**
|
|
* @name Species Production Rates
|
|
*/
|
|
//@{
|
|
|
|
/**
|
|
* Species creation rates [kmol/m^2/s]. Return the species
|
|
* creation rates in array cdot, which must be
|
|
* dimensioned at least as large as the total number of
|
|
* species in all phases of the kinetics
|
|
* model
|
|
*
|
|
*/
|
|
virtual void getCreationRates(doublereal* cdot) {
|
|
updateROP();
|
|
fill(cdot, cdot + m_kk, 0.0);
|
|
m_revProductStoich.incrementSpecies(
|
|
&m_kdata->m_ropf[0], cdot);
|
|
m_irrevProductStoich.incrementSpecies(
|
|
&m_kdata->m_ropf[0], cdot);
|
|
m_reactantStoich.incrementSpecies(
|
|
&m_kdata->m_ropr[0], cdot);
|
|
}
|
|
|
|
/**
|
|
* Species destruction rates [kmol/m^2/s]. Return the species
|
|
* destruction rates in array ddot, which must be
|
|
* dimensioned at least as large as the total number of
|
|
* species in all phases of the kinetics
|
|
* model
|
|
*
|
|
*/
|
|
virtual void getDestructionRates(doublereal* ddot) {
|
|
updateROP();
|
|
fill(ddot, ddot + m_kk, 0.0);
|
|
m_revProductStoich.incrementSpecies(
|
|
&m_kdata->m_ropr[0], ddot);
|
|
m_reactantStoich.incrementSpecies(
|
|
&m_kdata->m_ropf[0], ddot);
|
|
}
|
|
|
|
/**
|
|
* Species net production rates [kmol/m^2/s]. Return the species
|
|
* net production rates (creation - destruction) in array
|
|
* wdot, which must be dimensioned at least as large as the
|
|
* total number of species in all phases of the kinetics
|
|
* model
|
|
*/
|
|
virtual void getNetProductionRates(doublereal* net) {
|
|
updateROP();
|
|
fill(net, net + m_kk, 0.0);
|
|
m_revProductStoich.incrementSpecies(
|
|
&m_kdata->m_ropnet[0], net);
|
|
m_irrevProductStoich.incrementSpecies(
|
|
&m_kdata->m_ropnet[0], net);
|
|
m_reactantStoich.decrementSpecies(
|
|
&m_kdata->m_ropnet[0], net);
|
|
}
|
|
|
|
//@}
|
|
/**
|
|
* @name Reaction Mechanism Informational Query Routines
|
|
*/
|
|
//@{
|
|
|
|
/**
|
|
* Stoichiometric coefficient of species k as a reactant in
|
|
* reaction i.
|
|
*/
|
|
virtual doublereal reactantStoichCoeff(int k, int i) const {
|
|
return m_rrxn[k][i];
|
|
}
|
|
|
|
/**
|
|
* Stoichiometric coefficient of species k as a product in
|
|
* reaction i.
|
|
*/
|
|
virtual doublereal productStoichCoeff(int k, int i) const {
|
|
return m_prxn[k][i];
|
|
}
|
|
|
|
/**
|
|
* Flag specifying the type of reaction. The legal values and
|
|
* their meaning are specific to the particular kinetics
|
|
* manager.
|
|
*/
|
|
virtual int reactionType(int i) const {
|
|
return m_index[i].first;
|
|
}
|
|
|
|
/**
|
|
* True if reaction i has been declared to be reversible. If
|
|
* isReversible(i) is false, then the reverse rate of progress
|
|
* for reaction i is always zero.
|
|
*/
|
|
virtual bool isReversible(int i) {
|
|
if (find(m_revindex.begin(), m_revindex.end(), i)
|
|
< m_revindex.end()) return true;
|
|
else return false;
|
|
}
|
|
|
|
/**
|
|
* Return a string representing the reaction.
|
|
*/
|
|
virtual string reactionString(int i) const {
|
|
return m_rxneqn[i];
|
|
}
|
|
|
|
//@}
|
|
/**
|
|
* @name Reaction Mechanism Construction
|
|
*/
|
|
//@{
|
|
|
|
/**
|
|
* Prepare the class for the addition of reactions. This function
|
|
* must be called after instantiation of the class, but before
|
|
* any reactions are actually added to the mechanism.
|
|
* This function calculates m_kk the number of species in all
|
|
* phases participating in the reaction mechanism. We don't know
|
|
* m_kk previously, before all phases have been added.
|
|
*/
|
|
virtual void init();
|
|
|
|
/**
|
|
* Add a single reaction to the mechanism.
|
|
*/
|
|
virtual void addReaction(const ReactionData& r);
|
|
|
|
/**
|
|
* Finish adding reactions and prepare for use. This function
|
|
* must be called after all reactions are entered into the mechanism
|
|
* and before the mechanism is used to calculate reaction rates.
|
|
*/
|
|
virtual void finalize();
|
|
virtual bool ready() const;
|
|
|
|
|
|
void updateROP();
|
|
|
|
|
|
const vector<grouplist_t>& reactantGroups(int i)
|
|
{ return m_rgroups[i]; }
|
|
const vector<grouplist_t>& productGroups(int i)
|
|
{ return m_pgroups[i]; }
|
|
|
|
void _update_rates_T();
|
|
void _update_rates_phi();
|
|
void _update_rates_C();
|
|
void checkPartialEquil();
|
|
|
|
protected:
|
|
/**
|
|
* m_kk here is the number of species in all of the phases
|
|
* that participate in the kinetics mechanism.
|
|
*/
|
|
int m_kk;
|
|
|
|
Rate1<SurfaceArrhenius> m_rates;
|
|
//Rate1<Arrhenius> m_rates;
|
|
bool m_redo_rates;
|
|
|
|
/**
|
|
* Vector of information about reactions in the
|
|
* mechanism.
|
|
* The key is the reaction index (0 < i < m_ii).
|
|
* The first pair is the reactionType of the reaction.
|
|
* The second pair is ...
|
|
*/
|
|
mutable map<int, pair<int, int> > m_index;
|
|
|
|
vector<int> m_irrev;
|
|
|
|
StoichManagerN m_reactantStoich;
|
|
StoichManagerN m_revProductStoich;
|
|
StoichManagerN m_irrevProductStoich;
|
|
|
|
StoichManagerN m_globalReactantStoich;
|
|
|
|
int m_nirrev;
|
|
|
|
/**
|
|
* Number of reversible reactions in the mechanism
|
|
*/
|
|
int m_nrev;
|
|
|
|
map<int, vector<grouplist_t> > m_rgroups;
|
|
map<int, vector<grouplist_t> > m_pgroups;
|
|
|
|
vector<int> m_rxntype;
|
|
|
|
mutable vector<map<int, doublereal> > m_rrxn;
|
|
mutable vector<map<int, doublereal> > m_prxn;
|
|
|
|
vector_int m_revindex;
|
|
vector<string> m_rxneqn;
|
|
|
|
/**
|
|
* Temporary data storage used in calculating the rates of
|
|
* of reactions.
|
|
*/
|
|
EdgeKineticsData* m_kdata;
|
|
|
|
/**
|
|
* An array of generalized concentrations
|
|
* \f$ C_k \f$ that are defined such that \f$ a_k = C_k /
|
|
* C^0_k, \f$ where \f$ C^0_k \f$ is a standard concentration/
|
|
* These generalized concentrations are used
|
|
* by this kinetics manager class to compute the forward and
|
|
* reverse rates of elementary reactions. The "units" for the
|
|
* concentrations of each phase depend upon the implementation
|
|
* of kinetics within that phase.
|
|
* The order of the species within the vector is based on
|
|
* the order of listed ThermoPhase objects in the class, and the
|
|
* order of the species within each ThermoPhase class.
|
|
*/
|
|
vector_fp m_conc;
|
|
|
|
vector_fp m_mu0;
|
|
vector_fp m_phi;
|
|
vector_fp m_pot;
|
|
vector_fp m_rwork;
|
|
vector_fp m_E;
|
|
vector_fp m_beta;
|
|
vector_int m_ctrxn;
|
|
|
|
private:
|
|
|
|
int reactionNumber(){ return m_ii;}
|
|
void addElementaryReaction(const ReactionData& r);
|
|
void addGlobalReaction(const ReactionData& r);
|
|
void installReagents(const ReactionData& r);
|
|
|
|
void installGroups(int irxn, const vector<grouplist_t>& r,
|
|
const vector<grouplist_t>& p);
|
|
void updateKc();
|
|
|
|
void registerReaction(int rxnNumber, int type, int loc) {
|
|
m_index[rxnNumber] = pair<int, int>(type, loc);
|
|
}
|
|
void applyButlerVolmerCorrection(doublereal* kf);
|
|
bool m_finalized;
|
|
bool m_has_electrochem_rxns;
|
|
};
|
|
}
|
|
|
|
#endif
|