320 lines
9 KiB
C++
320 lines
9 KiB
C++
/**
|
|
* @file Kinetics.h
|
|
*
|
|
* $Author$
|
|
* $Revision$
|
|
* $Date$
|
|
*/
|
|
|
|
// Copyright 2001 California Institute of Technology
|
|
|
|
/**
|
|
* @defgroup kineticsGroup Kinetics
|
|
*/
|
|
|
|
#ifndef CT_KINETICS_H
|
|
#define CT_KINETICS_H
|
|
|
|
#include "ctexceptions.h"
|
|
//#include "Phase.h"
|
|
#include "ThermoPhase.h"
|
|
|
|
namespace Cantera {
|
|
|
|
class ReactionData;
|
|
|
|
/**
|
|
* Public interface for kinetics managers. This class serves as a
|
|
* base class to derive 'kinetics managers', which are classes
|
|
* that manage homogeneous chemistry within one phase.
|
|
*/
|
|
class Kinetics {
|
|
|
|
public:
|
|
|
|
// typedefs
|
|
typedef ThermoPhase thermo_t;
|
|
|
|
/// Constructor.
|
|
Kinetics() : m_ii(0), m_thermo(0), m_index(-1) {}
|
|
Kinetics(thermo_t* thermo)
|
|
: m_ii(0), m_index(-1) {
|
|
if (thermo) {
|
|
m_start.push_back(0);
|
|
m_thermo.push_back(thermo);
|
|
}
|
|
}
|
|
|
|
/// Destructor. Does nothing.
|
|
virtual ~Kinetics() {} // delete m_xml; }
|
|
|
|
int index(){ return m_index; }
|
|
void setIndex(int index) { m_index = index; }
|
|
|
|
//XML_Node& xml() { return *m_xml; }
|
|
|
|
/// Identifies subclass.
|
|
virtual int type() { return 0; }
|
|
|
|
int start(int n) { return m_start[n]; }
|
|
|
|
/// Number of reactions
|
|
int nReactions() const {return m_ii;}
|
|
|
|
/// Number of species
|
|
int nTotalSpecies() const {
|
|
int n=0, np;
|
|
np = nPhases();
|
|
for (int p = 0; p < np; p++) n += thermo(p).nSpecies();
|
|
return n;
|
|
}
|
|
|
|
/**
|
|
* Stoichiometric coefficient of species k as a reactant in
|
|
* reaction i.
|
|
*/
|
|
virtual doublereal reactantStoichCoeff(int k, int i) const {
|
|
err("reactantStoichCoeff");
|
|
return -1.0;
|
|
}
|
|
|
|
/**
|
|
* Stoichiometric coefficient of species k as a product in
|
|
* reaction i.
|
|
*/
|
|
virtual doublereal productStoichCoeff(int k, int i) const {
|
|
err("productStoichCoeff");
|
|
return -1.0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns a read-only reference to the vector of reactant
|
|
* index numbers for reaction i.
|
|
*/
|
|
virtual const vector_int& reactants(int i) const {
|
|
return m_reactants[i];
|
|
}
|
|
virtual const vector_int& products(int i) const {
|
|
return m_products[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 {
|
|
err("reactionType");
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
virtual void getFwdRatesOfProgress(doublereal* fwdROP) {
|
|
err("getFwdRatesOfProgress");
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual void getRevRatesOfProgress(doublereal* revROP) {
|
|
err("getRevRatesOfProgress");
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
virtual void getNetRatesOfProgress(doublereal* netROP) {
|
|
err("getNetRatesOfProgress");
|
|
}
|
|
|
|
/**
|
|
* 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){return false;}
|
|
|
|
/**
|
|
* Species creation rates [kmol/m^3]. Return the species
|
|
* creation rates in array cdot, which must be
|
|
* dimensioned at least as large as the total number of
|
|
* species.
|
|
*
|
|
*/
|
|
virtual void getCreationRates(doublereal* cdot) {
|
|
err("getCreationRates");
|
|
}
|
|
|
|
/**
|
|
* Species destruction rates [kmol/m^3]. Return the species
|
|
* destruction rates in array ddot, which must be
|
|
* dimensioned at least as large as the total number of
|
|
* species.
|
|
*
|
|
*/
|
|
virtual void getDestructionRates(doublereal* ddot) {
|
|
err("getDestructionRates");
|
|
}
|
|
|
|
/**
|
|
* Species net production rates [kmol/m^3]. 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.
|
|
*/
|
|
virtual void getNetProductionRates(doublereal* wdot) {
|
|
err("getNetProductionRates");
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
err("getEquilibriumConstants");
|
|
}
|
|
//@}
|
|
|
|
|
|
/**
|
|
* @name Reaction Mechanism Construction
|
|
*/
|
|
//@{
|
|
|
|
|
|
/**
|
|
* Get the nth Phase object.
|
|
*/
|
|
//phase_t& phase(int n=0) { return *m_phase[n]; }
|
|
//const phase_t& phase(int n=0) const { return *m_phase[n]; }
|
|
int nPhases() const { return m_thermo.size(); }
|
|
int phaseIndex(string ph) { return m_phaseindex[ph] - 1; }
|
|
|
|
/**
|
|
* Add a phase.
|
|
*/
|
|
void addPhase(thermo_t& thermo) {
|
|
if (m_thermo.size() > 0) {
|
|
m_start.push_back(m_start.back()
|
|
+ m_thermo.back()->nSpecies());
|
|
}
|
|
else {
|
|
m_start.push_back(0);
|
|
}
|
|
m_thermo.push_back(&thermo);
|
|
m_phaseindex[m_thermo.back()->id()] = nPhases();
|
|
}
|
|
thermo_t& thermo(int n=0) { return *m_thermo[n]; }
|
|
const thermo_t& thermo(int n=0) const { return *m_thermo[n]; }
|
|
thermo_t& phase(int n=0) { return *m_thermo[n]; }
|
|
const thermo_t& phase(int n=0) const { return *m_thermo[n]; }
|
|
|
|
int speciesIndex(int k, int n) {
|
|
return m_start[n] + k;
|
|
}
|
|
|
|
int speciesIndex(string nm, string ph = "<any>") {
|
|
int np = m_thermo.size();
|
|
int k;
|
|
string id;
|
|
for (int n = 0; n < np; n++) {
|
|
id = thermo(n).id();
|
|
if (ph == id) {
|
|
k = thermo(n).speciesIndex(nm);
|
|
if (k < 0) return -1;
|
|
return k + m_start[n];
|
|
}
|
|
else if (ph == "<any>") {
|
|
k = thermo(n).speciesIndex(nm);
|
|
if (k >= 0) return k + m_start[n];
|
|
}
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
/**
|
|
* Prepare to add reactions.
|
|
*/
|
|
virtual void init() {err("init");}
|
|
|
|
/// Finished adding reactions. Prepare for use.
|
|
virtual void finalize() {err("finalize");}
|
|
|
|
virtual void addReaction(const ReactionData& r) {err("addReaction");}
|
|
|
|
virtual string reactionString(int i) const {
|
|
err("reactionString"); return "<null>";
|
|
}
|
|
|
|
|
|
virtual const vector<grouplist_t>& reactantGroups(int i)
|
|
{ err("reactantGroups"); return m_dummygroups; }
|
|
|
|
virtual const vector<grouplist_t>& productGroups(int i)
|
|
{ err("productGroups"); return m_dummygroups; }
|
|
|
|
/**
|
|
* @name Altering Reaction Rates
|
|
*
|
|
* These methods alter reaction rates. They are designed
|
|
* primarily for carrying out sensitivity analysis.
|
|
*/
|
|
//@{
|
|
|
|
/// The current value of the multiplier for reaction i.
|
|
doublereal multiplier(int i) const {return m_perturb[i];}
|
|
|
|
/// Set the multiplier for reaction i to f.
|
|
void setMultiplier(int i, doublereal f) {m_perturb[i] = f;}
|
|
|
|
//@}
|
|
|
|
void incrementRxnCount() { m_ii++; m_perturb.push_back(1.0); }
|
|
|
|
virtual bool ready() const {return false;}
|
|
|
|
protected:
|
|
|
|
int m_ii;
|
|
vector_fp m_perturb;
|
|
vector<vector_int> m_reactants;
|
|
vector<vector_int> m_products;
|
|
vector<thermo_t*> m_thermo;
|
|
vector_int m_start;
|
|
// XML_Node* m_xml;
|
|
map<string, int> m_phaseindex;
|
|
int m_index;
|
|
|
|
private:
|
|
|
|
vector<grouplist_t> m_dummygroups;
|
|
void err(string m) const {
|
|
throw CanteraError("Kinetics::"+m,"Base class method called.");
|
|
}
|
|
};
|
|
|
|
typedef Kinetics kinetics_t;
|
|
}
|
|
|
|
|
|
|
|
#endif
|