314 lines
8.9 KiB
C++
314 lines
8.9 KiB
C++
/**
|
|
* @file Kinetics.cpp
|
|
* Declarations for the base class for kinetics
|
|
* managers (see \ref kineticsmgr and class
|
|
* \link Cantera::Kinetics Kinetics\endlink).
|
|
*
|
|
* Kinetics managers calculate rates of progress of species due to homogeneous or heterogeneous kinetics.
|
|
*/
|
|
// Copyright 2001-2004 California Institute of Technology
|
|
|
|
|
|
|
|
#include "InterfaceKinetics.h"
|
|
#include "SurfPhase.h"
|
|
#include "StoichManager.h"
|
|
#include "RateCoeffMgr.h"
|
|
|
|
#include "ImplicitSurfChem.h"
|
|
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
|
|
namespace Cantera {
|
|
|
|
|
|
Kinetics::Kinetics() :
|
|
m_ii(0),
|
|
m_nTotalSpecies(0),
|
|
m_thermo(0),
|
|
m_index(-1),
|
|
m_surfphase(-1),
|
|
m_rxnphase(-1),
|
|
m_mindim(4)
|
|
{
|
|
}
|
|
|
|
Kinetics::~Kinetics(){}
|
|
|
|
|
|
// Copy Constructor for the %Kinetics object.
|
|
/*
|
|
* Currently, this is not fully implemented. If called it will
|
|
* throw an exception.
|
|
*/
|
|
Kinetics::Kinetics(const Kinetics &right) :
|
|
m_ii(0),
|
|
m_nTotalSpecies(0),
|
|
m_thermo(0),
|
|
m_index(-1),
|
|
m_surfphase(-1),
|
|
m_rxnphase(-1),
|
|
m_mindim(4)
|
|
{
|
|
/*
|
|
* Call the assignment operator
|
|
*/
|
|
*this = operator=(right);
|
|
}
|
|
|
|
// Assignment operator
|
|
/*
|
|
* This is NOT a virtual function.
|
|
*
|
|
* @param right Reference to %Kinetics object to be copied into the
|
|
* current one.
|
|
*/
|
|
Kinetics& Kinetics::
|
|
operator=(const Kinetics &right) {
|
|
/*
|
|
* Check for self assignment.
|
|
*/
|
|
if (this == &right) return *this;
|
|
|
|
m_ii = right.m_ii;
|
|
m_nTotalSpecies = right.m_nTotalSpecies;
|
|
m_perturb = right.m_perturb;
|
|
m_reactants = right.m_reactants;
|
|
m_products = right.m_products;
|
|
|
|
m_thermo = right.m_thermo; // DANGER -> shallow pointer copy
|
|
|
|
m_start = right.m_start;
|
|
m_phaseindex = right.m_phaseindex;
|
|
m_index = right.m_index;
|
|
m_surfphase = right.m_surfphase;
|
|
m_rxnphase = right.m_rxnphase;
|
|
m_mindim = right.m_mindim;
|
|
m_dummygroups = right.m_dummygroups;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
// Duplication routine for objects which inherit from
|
|
// Kinetics
|
|
/*
|
|
* This virtual routine can be used to duplicate %Kinetics objects
|
|
* inherited from %Kinetics even if the application only has
|
|
* a pointer to %Kinetics to work with.
|
|
*
|
|
* These routines are basically wrappers around the derived copy
|
|
* constructor.
|
|
*/
|
|
Kinetics *Kinetics::duplMyselfAsKinetics() const {
|
|
Kinetics* tp = new Kinetics(*this);
|
|
return tp;
|
|
}
|
|
|
|
|
|
|
|
int Kinetics::ID() const {
|
|
return 0;
|
|
}
|
|
|
|
int Kinetics::type() const {
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Takes as input an array of properties for all species in the
|
|
* mechanism and copies those values beloning to a particular
|
|
* phase to the output array.
|
|
* @param data Input data array.
|
|
* @param phase Pointer to one of the phase objects participating
|
|
* in this reaction mechanism
|
|
* @param phase_data Output array where the values for the the
|
|
* specified phase are to be written.
|
|
*/
|
|
void Kinetics::selectPhase(const doublereal* data, const thermo_t* phase,
|
|
doublereal* phase_data) {
|
|
for (size_t n = 0; n < nPhases(); n++) {
|
|
if (phase == m_thermo[n]) {
|
|
size_t nsp = phase->nSpecies();
|
|
copy(data + m_start[n],
|
|
data + m_start[n] + nsp, phase_data);
|
|
return;
|
|
}
|
|
}
|
|
throw CanteraError("Kinetics::selectPhase", "Phase not found.");
|
|
}
|
|
|
|
|
|
/**
|
|
* kineticsSpeciesName():
|
|
*
|
|
* Return the string name of the kth species in the kinetics
|
|
* manager. k is an integer from 0 to ktot - 1, where ktot is
|
|
* the number of species in the kinetics manager, which is the
|
|
* sum of the number of species in all phases participating in
|
|
* the kinetics manager. If k is out of bounds, the string
|
|
* "<unknown>" is returned.
|
|
*/
|
|
string Kinetics::kineticsSpeciesName(size_t k) const {
|
|
for (size_t n = m_start.size()-1; n >= 0; n--) {
|
|
if (k >= m_start[n]) {
|
|
return thermo(n).speciesName(k - m_start[n]);
|
|
}
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
/**
|
|
* kineticsSpeciesIndex():
|
|
*
|
|
* This routine will look up a species number based on
|
|
* the input string nm. The lookup of species will
|
|
* occur for all phases listed in the kinetics object,
|
|
* unless the string ph refers to a specific phase of
|
|
* the object.
|
|
*
|
|
* return
|
|
* - If a match is found, the position in the species list
|
|
* is returned.
|
|
* - If a specific phase is specified and no match is found,
|
|
* the value -1 is returned.
|
|
* - If no match is found in any phase, the value -2 is returned.
|
|
*/
|
|
size_t Kinetics::kineticsSpeciesIndex(std::string nm, std::string ph) const {
|
|
size_t np = m_thermo.size();
|
|
size_t k;
|
|
string id;
|
|
for (size_t n = 0; n < np; n++) {
|
|
id = thermo(n).id();
|
|
if (ph == id) {
|
|
k = thermo(n).speciesIndex(nm);
|
|
if (k == -1) return -1;
|
|
return k + m_start[n];
|
|
}
|
|
else if (ph == "<any>") {
|
|
/*
|
|
* Call the speciesIndex() member function of the
|
|
* ThermoPhase object to find a match.
|
|
*/
|
|
k = thermo(n).speciesIndex(nm);
|
|
if (k >= 0) return k + m_start[n];
|
|
}
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
/**
|
|
* This function looks up the string name of a species and
|
|
* returns a reference to the ThermoPhase object of the
|
|
* phase where the species resides.
|
|
* Will throw an error if the species string doesn't match.
|
|
*/
|
|
thermo_t& Kinetics::speciesPhase(std::string nm) {
|
|
size_t np = m_thermo.size();
|
|
size_t k;
|
|
string id;
|
|
for (size_t n = 0; n < np; n++) {
|
|
k = thermo(n).speciesIndex(nm);
|
|
if (k != -1) return thermo(n);
|
|
}
|
|
throw CanteraError("speciesPhase", "unknown species "+nm);
|
|
return thermo(0);
|
|
}
|
|
|
|
//==============================================================================================
|
|
/*
|
|
* This function takes as an argument the kineticsSpecies index
|
|
* (i.e., the list index in the list of species in the kinetics
|
|
* manager) and returns the index of the phase owning the
|
|
* species.
|
|
*/
|
|
int Kinetics::speciesPhaseIndex(int k) {
|
|
int np = m_start.size();
|
|
for (int n = np-1; n >= 0; n--) {
|
|
if (k >= m_start[n]) {
|
|
return n;
|
|
}
|
|
}
|
|
throw CanteraError("speciesPhaseIndex", "illegal species index: "+int2str(k));
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Add a phase to the kinetics manager object. This must
|
|
* be done before the function init() is called or
|
|
* before any reactions are input.
|
|
* The following fields are updated:
|
|
* m_start -> vector of integers, containing the
|
|
* starting position of the species for
|
|
* each phase in the kinetics mechanism.
|
|
* m_surfphase -> index of the surface phase.
|
|
* m_thermo -> vector of pointers to ThermoPhase phases
|
|
* that participate in the kinetics
|
|
* mechanism.
|
|
* m_phaseindex -> map containing the string id of each
|
|
* ThermoPhase phase as a key and the
|
|
* index of the phase within the kinetics
|
|
* manager object as the value.
|
|
*/
|
|
void Kinetics::addPhase(thermo_t& thermo) {
|
|
|
|
// if not the first thermo object, set the start position
|
|
// to that of the last object added + the number of its species
|
|
if (m_thermo.size() > 0) {
|
|
m_start.push_back(m_start.back()
|
|
+ m_thermo.back()->nSpecies());
|
|
}
|
|
// otherwise start at 0
|
|
else {
|
|
m_start.push_back(0);
|
|
}
|
|
|
|
// the phase with lowest dimensionality is assumed to be the
|
|
// phase/interface at which reactions take place
|
|
if (thermo.nDim() <= m_mindim) {
|
|
m_mindim = thermo.nDim();
|
|
m_rxnphase = nPhases();
|
|
}
|
|
|
|
// there should only be one surface phase
|
|
int ptype = -100;
|
|
if (type() == cEdgeKinetics) ptype = cEdge;
|
|
else if (type() == cInterfaceKinetics) ptype = cSurf;
|
|
if (thermo.eosType() == ptype) {
|
|
// if (m_surfphase >= 0) {
|
|
// throw CanteraError("Kinetics::addPhase",
|
|
// "cannot add more than one surface phase");
|
|
// }
|
|
m_surfphase = nPhases();
|
|
m_rxnphase = nPhases();
|
|
}
|
|
m_thermo.push_back(&thermo);
|
|
m_phaseindex[m_thermo.back()->id()] = nPhases();
|
|
}
|
|
|
|
void Kinetics::finalize() {
|
|
m_nTotalSpecies = 0;
|
|
int np = nPhases();
|
|
for (int n = 0; n < np; n++) {
|
|
int nsp = m_thermo[n]->nSpecies();
|
|
m_nTotalSpecies += nsp;
|
|
}
|
|
}
|
|
|
|
|
|
//! Private function of the class Kinetics, indicating that a function
|
|
//! inherited from the base class hasn't had a definition assigned to it
|
|
/*!
|
|
* @param m String message
|
|
*/
|
|
void Kinetics::err(std::string m) const {
|
|
throw CanteraError("Kinetics::" + m,
|
|
"The default Base class method was called, when "
|
|
"the inherited class's method should "
|
|
"have been called");
|
|
}
|
|
|
|
}
|