/** * @file Kinetics.cpp * */ // Copyright 2001-2004 California Institute of Technology #include "InterfaceKinetics.h" #include "SurfPhase.h" #include "ReactionData.h" #include "StoichManager.h" #include "RateCoeffMgr.h" #include "ImplicitSurfChem.h" #include using namespace std; namespace Cantera { Kinetics::Kinetics() : m_ii(0), m_thermo(0), m_index(-1), m_surfphase(-1), m_rxnphase(-1), m_mindim(4) {} /* Kinetics::Kinetics(thermo_t* thermo) : m_ii(0), m_index(-1), m_surfphase(-1) , m_rxnphase(0), m_mindim(4) { if (thermo) { addPhase(*thermo); } deprecatedMethod("Kinetics","Kinetics(thermo_t*)","Kinetics()"); removeAtVersion("Kinetics(thermo_t*)","1.6.0"); } */ Kinetics::~Kinetics(){} /** * 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) { int n, nsp, np = nPhases(); for (n = 0; n < np; n++) { if (phase == m_thermo[n]) { 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 * "" is returned. */ string Kinetics::kineticsSpeciesName(int k) const { int np = m_start.size(); for (int n = np-1; n >= 0; n--) { if (k >= m_start[n]) { return thermo(n).speciesName(k - m_start[n]); } } return ""; } /** * 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. */ int Kinetics::kineticsSpeciesIndex(string nm, string ph) const { int np = static_cast(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 == "") { /* * 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(string nm) { int np = static_cast(m_thermo.size()); int k; string id; for (int n = 0; n < np; n++) { k = thermo(n).speciesIndex(nm); if (k >= 0) return thermo(n); } throw CanteraError("speciesPhase", "unknown species "+nm); } /** * 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)); } /** * 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(); } /** * err(): * * Private function of the class Kinetics, indicating that a function * inherited from the base class hasn't had a definition assigned to it */ void Kinetics::err(string m) const { throw CanteraError("Kinetics::" + m, "The default Base class method was called, when " "the inherited class's method should " "have been called"); } }