Cantera  2.1.2
RxnRates.h
Go to the documentation of this file.
1 /**
2  * @file RxnRates.h
3  *
4  */
5 // Copyright 2001 California Institute of Technology
6 
7 
8 #ifndef CT_RXNRATES_H
9 #define CT_RXNRATES_H
10 
11 #include "reaction_defs.h"
12 #include "ReactionData.h"
13 
16 
17 #include <iostream>
18 
19 namespace Cantera
20 {
21 
22 //! Arrhenius reaction rate type depends only on temperature
23 /**
24  * A reaction rate coefficient of the following form.
25  *
26  * \f[
27  * k_f = A T^b \exp (-E/RT)
28  * \f]
29  *
30  */
31 class Arrhenius
32 {
33 public:
34  //! return the rate coefficient type.
35  static int type() {
36  return ARRHENIUS_REACTION_RATECOEFF_TYPE;
37  }
38 
39  //! Default constructor.
41  m_logA(-1.0E300),
42  m_b(0.0),
43  m_E(0.0),
44  m_A(0.0) {}
45 
46  //! Constructor from ReactionData.
47  explicit Arrhenius(const ReactionData& rdata) :
48  m_b(rdata.rateCoeffParameters[1]),
49  m_E(rdata.rateCoeffParameters[2]),
50  m_A(rdata.rateCoeffParameters[0]) {
51  if (m_A <= 0.0) {
52  m_logA = -1.0E300;
53  } else {
54  m_logA = std::log(m_A);
55  }
56  }
57 
58  /// Constructor.
59  /// @param A pre-exponential. The unit system is
60  /// (kmol, m, s). The actual units depend on the reaction
61  /// order and the dimensionality (surface or bulk).
62  /// @param b Temperature exponent. Non-dimensional.
63  /// @param E Activation energy in temperature units. Kelvin.
64  Arrhenius(doublereal A, doublereal b, doublereal E) :
65  m_b(b),
66  m_E(E),
67  m_A(A) {
68  if (m_A <= 0.0) {
69  m_logA = -1.0E300;
70  } else {
71  m_logA = log(m_A);
72  }
73  }
74 
75  //! Update concentration-dependent parts of the rate coefficient.
76  /*!
77  * For this class, there are no
78  * concentration-dependent parts, so this method does nothing.
79  */
80  void update_C(const doublereal* c) {
81  }
82 
83  /**
84  * Update the value of the logarithm of the rate constant.
85  *
86  * Note, this function should never be called for negative A values.
87  * If it does then it will produce a negative overflow result, and
88  * a zero net forwards reaction rate, instead of a negative reaction
89  * rate constant that is the expected result.
90  */
91  doublereal update(doublereal logT, doublereal recipT) const {
92  return m_logA + m_b*logT - m_E*recipT;
93  }
94 
95  /**
96  * Update the value the rate constant.
97  *
98  * This function returns the actual value of the rate constant.
99  * It can be safely called for negative values of the pre-exponential
100  * factor.
101  */
102  doublereal updateRC(doublereal logT, doublereal recipT) const {
103  return m_A * std::exp(m_b*logT - m_E*recipT);
104  }
105 
106 
107  void writeUpdateRHS(std::ostream& s) const {
108  s << " exp(" << m_logA;
109  if (m_b != 0.0) {
110  s << " + " << m_b << " * tlog";
111  }
112  if (m_E != 0.0) {
113  s << " - " << m_E << " * rt";
114  }
115  s << ");" << std::endl;
116  }
117 
118  doublereal activationEnergy_R() const {
119  return m_E;
120  }
121 
122  static bool alwaysComputeRate() {
123  return false;
124  }
125 
126 protected:
127  doublereal m_logA, m_b, m_E, m_A;
128 };
129 
130 
131 /**
132  * An Arrhenius rate with coverage-dependent terms.
133  *
134  * The rate expression is given by:
135  * \f[
136  * k_f = A T^b \exp \left(
137  * \sum a_k \theta_k
138  * - \frac{1}{RT} \left( E_a + \sum E_k\theta_k \right)
139  * + \sum m_k \log \theta_k
140  * \right)
141  * \f]
142  * where the parameters \f$ (a_k, E_k, m_k) \f$ describe the dependency on the
143  * surface coverage of species \f$k, \theta_k \f$.
144  */
146 {
147 
148 public:
149  static int type() {
150  return SURF_ARRHENIUS_REACTION_RATECOEFF_TYPE;
151  }
152 
153  SurfaceArrhenius() :
154  m_logA(-1.0E300),
155  m_b(0.0),
156  m_E(0.0),
157  m_A(0.0),
158  m_acov(0.0),
159  m_ecov(0.0),
160  m_mcov(0.0),
161  m_ncov(0),
162  m_nmcov(0) {
163  }
164 
165  explicit SurfaceArrhenius(const ReactionData& rdata) :
166  m_b(rdata.rateCoeffParameters[1]),
167  m_E(rdata.rateCoeffParameters[2]),
168  m_A(rdata.rateCoeffParameters[0]),
169  m_acov(0.0),
170  m_ecov(0.0),
171  m_mcov(0.0),
172  m_ncov(0),
173  m_nmcov(0) {
174  if (m_A <= 0.0) {
175  m_logA = -1.0E300;
176  } else {
177  m_logA = std::log(m_A);
178  }
179 
180  const vector_fp& data = rdata.rateCoeffParameters;
181  if (data.size() >= 7) {
182  for (size_t n = 3; n < data.size()-3; n += 4) {
183  addCoverageDependence(size_t(data[n]), data[n+1],
184  data[n+2], data[n+3]);
185  }
186  }
187  }
188 
189  void addCoverageDependence(size_t k, doublereal a,
190  doublereal m, doublereal e) {
191  m_ncov++;
192  m_sp.push_back(k);
193  m_ac.push_back(a);
194  m_ec.push_back(e);
195  if (m != 0.0) {
196  m_msp.push_back(k);
197  m_mc.push_back(m);
198  m_nmcov++;
199  }
200  }
201 
202  void update_C(const doublereal* theta) {
203  m_acov = 0.0;
204  m_ecov = 0.0;
205  m_mcov = 0.0;
206  size_t k;
207  doublereal th;
208  for (size_t n = 0; n < m_ncov; n++) {
209  k = m_sp[n];
210  m_acov += m_ac[n] * theta[k];
211  m_ecov += m_ec[n] * theta[k];
212  }
213  for (size_t n = 0; n < m_nmcov; n++) {
214  k = m_msp[n];
215  // changed n to k, dgg 1/22/04
216  th = std::max(theta[k], Tiny);
217  // th = fmaxx(theta[n], Tiny);
218  m_mcov += m_mc[n]*std::log(th);
219  }
220  }
221 
222  /**
223  * Update the value of the logarithm of the rate constant.
224  *
225  * This calculation is not safe for negative values of
226  * the preexponential.
227  */
228  doublereal update(doublereal logT, doublereal recipT) const {
229  return m_logA + m_acov + m_b*logT
230  - (m_E + m_ecov)*recipT + m_mcov;
231  }
232 
233  /**
234  * Update the value the rate constant.
235  *
236  * This function returns the actual value of the rate constant.
237  * It can be safely called for negative values of the pre-exponential
238  * factor.
239  */
240  doublereal updateRC(doublereal logT, doublereal recipT) const {
241  return m_A * std::exp(m_acov + m_b*logT - (m_E + m_ecov)*recipT + m_mcov);
242  }
243 
244  doublereal activationEnergy_R() const {
245  return m_E + m_ecov;
246  }
247 
248  static bool alwaysComputeRate() {
249  return true;
250  }
251 
252 protected:
253  doublereal m_logA, m_b, m_E, m_A;
254  doublereal m_acov, m_ecov, m_mcov;
255  std::vector<size_t> m_sp, m_msp;
256  vector_fp m_ac, m_ec, m_mc;
257  size_t m_ncov, m_nmcov;
258 };
259 
260 
261 //! Arrhenius reaction rate type depends only on temperature
262 /**
263  * A reaction rate coefficient of the following form.
264  *
265  * \f[
266  * k_f = A T^b \exp (-E/RT)
267  * \f]
268  *
269  */
271 {
272 public:
273 
274  //! return the rate coefficient type.
275  static int type() {
276  return EXCHANGE_CURRENT_REACTION_RATECOEFF_TYPE;
277  }
278 
279  //! Default constructor.
281  m_logA(-1.0E300),
282  m_b(0.0),
283  m_E(0.0),
284  m_A(0.0) {}
285 
286  //! Constructor with Arrhenius parameters from a ReactionData struct.
287  explicit ExchangeCurrent(const ReactionData& rdata) :
288  m_b(rdata.rateCoeffParameters[1]),
289  m_E(rdata.rateCoeffParameters[2]),
290  m_A(rdata.rateCoeffParameters[0]) {
291  if (m_A <= 0.0) {
292  m_logA = -1.0E300;
293  } else {
294  m_logA = std::log(m_A);
295  }
296  }
297 
298  /// Constructor.
299  /// @param A pre-exponential. The unit system is
300  /// (kmol, m, s). The actual units depend on the reaction
301  /// order and the dimensionality (surface or bulk).
302  /// @param b Temperature exponent. Non-dimensional.
303  /// @param E Activation energy in temperature units. Kelvin.
304  ExchangeCurrent(doublereal A, doublereal b, doublereal E) :
305  m_b(b),
306  m_E(E),
307  m_A(A) {
308  if (m_A <= 0.0) {
309  m_logA = -1.0E300;
310  } else {
311  m_logA = std::log(m_A);
312  }
313  }
314 
315  //! Update concentration-dependent parts of the rate coefficient.
316  /*!
317  * For this class, there are no
318  * concentration-dependent parts, so this method does nothing.
319  */
320  void update_C(const doublereal* c) {
321  }
322 
323  /**
324  * Update the value of the logarithm of the rate constant.
325  *
326  * Note, this function should never be called for negative A values.
327  * If it does then it will produce a negative overflow result, and
328  * a zero net forwards reaction rate, instead of a negative reaction
329  * rate constant that is the expected result.
330  */
331  doublereal update(doublereal logT, doublereal recipT) const {
332  return m_logA + m_b*logT - m_E*recipT;
333  }
334 
335  /**
336  * Update the value the rate constant.
337  *
338  * This function returns the actual value of the rate constant.
339  * It can be safely called for negative values of the pre-exponential
340  * factor.
341  */
342  doublereal updateRC(doublereal logT, doublereal recipT) const {
343  return m_A * std::exp(m_b*logT - m_E*recipT);
344  }
345 
346  void writeUpdateRHS(std::ostream& s) const {
347  s << " exp(" << m_logA;
348  if (m_b != 0.0) {
349  s << " + " << m_b << " * tlog";
350  }
351  if (m_E != 0.0) {
352  s << " - " << m_E << " * rt";
353  }
354  s << ");" << std::endl;
355  }
356 
357  doublereal activationEnergy_R() const {
358  return m_E;
359  }
360 
361  static bool alwaysComputeRate() {
362  return false;
363  }
364 
365 protected:
366  doublereal m_logA, m_b, m_E, m_A;
367 };
368 
369 
370 class Plog
371 {
372 public:
373  //! return the rate coefficient type.
374  static int type() {
375  return PLOG_REACTION_RATECOEFF_TYPE;
376  }
377 
378  //! Default constructor.
379  Plog() {}
380 
381  //! Constructor from ReactionData.
382  explicit Plog(const ReactionData& rdata) :
383  logP1_(1000),
384  logP2_(-1000),
385  maxRates_(1) {
386  typedef std::multimap<double, vector_fp>::const_iterator iter_t;
387 
388  size_t j = 0;
389  size_t rateCount = 0;
390  // Insert intermediate pressures
391  for (iter_t iter = rdata.plogParameters.begin();
392  iter != rdata.plogParameters.end();
393  iter++) {
394  double logp = std::log(iter->first);
395  if (pressures_.empty() || pressures_.rbegin()->first != logp) {
396  // starting a new group
397  pressures_[logp] = std::make_pair(j, j+1);
398  rateCount = 1;
399  } else {
400  // another rate expression at the same pressure
401  pressures_[logp].second = j+1;
402  rateCount++;
403  }
404  maxRates_ = std::max(rateCount, maxRates_);
405 
406  j++;
407  A_.push_back(iter->second[0]);
408  n_.push_back(iter->second[1]);
409  Ea_.push_back(iter->second[2]);
410  }
411 
412  // For pressures with only one Arrhenius expression, it is more
413  // efficient to work with log(A)
414  for (pressureIter iter = pressures_.begin();
415  iter != pressures_.end();
416  iter++) {
417  if (iter->second.first == iter->second.second - 1) {
418  A_[iter->second.first] = std::log(A_[iter->second.first]);
419  }
420  }
421 
422  // Duplicate the first and last groups to handle P < P_0 and P > P_N
423  pressures_.insert(std::make_pair(-1000.0, pressures_.begin()->second));
424  pressures_.insert(std::make_pair(1000.0, pressures_.rbegin()->second));
425 
426  // Resize work arrays
427  A1_.resize(maxRates_);
428  A2_.resize(maxRates_);
429  n1_.resize(maxRates_);
430  n2_.resize(maxRates_);
431  Ea1_.resize(maxRates_);
432  Ea2_.resize(maxRates_);
433 
434  if (rdata.validate) {
435  validate(rdata);
436  }
437  }
438 
439  //! Update concentration-dependent parts of the rate coefficient.
440  //! @param c natural log of the pressure in Pa
441  void update_C(const doublereal* c) {
442  logP_ = c[0];
443  if (logP_ > logP1_ && logP_ < logP2_) {
444  return;
445  }
446 
447  pressureIter iter = pressures_.upper_bound(c[0]);
448  AssertThrowMsg(iter != pressures_.end(), "Plog::update_C",
449  "Pressure out of range: " + fp2str(logP_));
450  AssertThrowMsg(iter != pressures_.begin(), "Plog::update_C",
451  "Pressure out of range: " + fp2str(logP_));
452 
453  // upper interpolation pressure
454  logP2_ = iter->first;
455  size_t start = iter->second.first;
456  m2_ = iter->second.second - start;
457  for (size_t m = 0; m < m2_; m++) {
458  A2_[m] = A_[start+m];
459  n2_[m] = n_[start+m];
460  Ea2_[m] = Ea_[start+m];
461  }
462 
463  // lower interpolation pressure
464  logP1_ = (--iter)->first;
465  start = iter->second.first;
466  m1_ = iter->second.second - start;
467  for (size_t m = 0; m < m1_; m++) {
468  A1_[m] = A_[start+m];
469  n1_[m] = n_[start+m];
470  Ea1_[m] = Ea_[start+m];
471  }
472 
473  rDeltaP_ = 1.0 / (logP2_ - logP1_);
474  }
475 
476  /**
477  * Update the value of the logarithm of the rate constant.
478  */
479  doublereal update(doublereal logT, doublereal recipT) const {
480  double log_k1, log_k2;
481  if (m1_ == 1) {
482  log_k1 = A1_[0] + n1_[0] * logT - Ea1_[0] * recipT;
483  } else {
484  double k = 1e-300; // non-zero to make log(k) finite
485  for (size_t m = 0; m < m1_; m++) {
486  k += A1_[m] * std::exp(n1_[m] * logT - Ea1_[m] * recipT);
487  }
488  log_k1 = std::log(k);
489  }
490 
491  if (m2_ == 1) {
492  log_k2 = A2_[0] + n2_[0] * logT - Ea2_[0] * recipT;
493  } else {
494  double k = 1e-300; // non-zero to make log(k) finite
495  for (size_t m = 0; m < m2_; m++) {
496  k += A2_[m] * std::exp(n2_[m] * logT - Ea2_[m] * recipT);
497  }
498  log_k2 = std::log(k);
499  }
500 
501  return log_k1 + (log_k2 - log_k1) * (logP_ - logP1_) * rDeltaP_;
502  }
503 
504  /**
505  * Update the value the rate constant.
506  *
507  * This function returns the actual value of the rate constant.
508  */
509  doublereal updateRC(doublereal logT, doublereal recipT) const {
510  return std::exp(update(logT, recipT));
511  }
512 
513  doublereal activationEnergy_R() const {
514  throw CanteraError("Plog::activationEnergy_R", "Not implemented");
515  }
516 
517  static bool alwaysComputeRate() {
518  return false;
519  }
520 
521  //! Check to make sure that the rate expression is finite over a range of
522  //! temperatures at each interpolation pressure. This is potentially an
523  //! issue when one of the Arrhenius expressions at a particular pressure
524  //! has a negative pre-exponential factor.
525  void validate(const ReactionData& rdata) {
526  double T[] = {1.0, 10.0, 100.0, 1000.0, 10000.0};
527  for (pressureIter iter = pressures_.begin();
528  iter->first < 1000;
529  iter++) {
530  update_C(&iter->first);
531  for (size_t i=0; i < 5; i++) {
532  double k = updateRC(log(T[i]), 1.0/T[i]);
533  if (!(k >= 0)) {
534  // k is NaN. Increment the iterator so that the error
535  // message will correctly indicate that the problematic rate
536  // expression is at the higher of the adjacent pressures.
537  throw CanteraError("Plog::validate",
538  "Invalid rate coefficient for reaction #" +
539  int2str(rdata.number) + ":\n" + rdata.equation + "\n" +
540  "at P = " + fp2str(std::exp((++iter)->first)) +
541  ", T = " + fp2str(T[i]));
542  }
543  }
544  }
545  }
546 
547 protected:
548  //! log(p) to (index range) in A_, n, Ea vectors
549  std::map<double, std::pair<size_t, size_t> > pressures_;
550  typedef std::map<double, std::pair<size_t, size_t> >::iterator pressureIter;
551 
552  vector_fp A_; //!< Pre-exponential factor at each pressure (or log(A))
553  vector_fp n_; //!< Temperature exponent at each pressure [dimensionless]
554  vector_fp Ea_; //!< Activation energy at each pressure [K]
555 
556  double logP_; //!< log(p) at the current state
557  double logP1_, logP2_; //!< log(p) at the lower / upper pressure reference
558 
559  //! Pre-exponential factors at lower / upper pressure reference.
560  //! Stored as log(A) when there is only one at the corresponding pressure.
561  vector_fp A1_, A2_;
562  vector_fp n1_, n2_; //!< n at lower / upper pressure reference
563  vector_fp Ea1_, Ea2_; //!< Activation energy at lower / upper pressure reference
564 
565  //! Number of Arrhenius expressions at lower / upper pressure references
566  size_t m1_, m2_;
567  double rDeltaP_; //!< reciprocal of (logP2 - logP1)
568 
569  size_t maxRates_; //!< The maximum number of rates at any given pressure
570 };
571 
572 
573 class ChebyshevRate
574 {
575 public:
576  //! return the rate coefficient type.
577  static int type() {
578  return CHEBYSHEV_REACTION_RATECOEFF_TYPE;
579  }
580 
581  //! Default constructor.
582  ChebyshevRate() {}
583 
584  //! Constructor from ReactionData.
585  explicit ChebyshevRate(const ReactionData& rdata) :
586  nP_(rdata.chebDegreeP),
587  nT_(rdata.chebDegreeT),
588  chebCoeffs_(rdata.chebCoeffs),
589  dotProd_(rdata.chebDegreeT) {
590  double logPmin = std::log10(rdata.chebPmin);
591  double logPmax = std::log10(rdata.chebPmax);
592  double TminInv = 1.0 / rdata.chebTmin;
593  double TmaxInv = 1.0 / rdata.chebTmax;
594 
595  TrNum_ = - TminInv - TmaxInv;
596  TrDen_ = 1.0 / (TmaxInv - TminInv);
597  PrNum_ = - logPmin - logPmax;
598  PrDen_ = 1.0 / (logPmax - logPmin);
599  }
600 
601  //! Update concentration-dependent parts of the rate coefficient.
602  //! @param c base-10 logarithm of the pressure in Pa
603  void update_C(const doublereal* c) {
604  double Pr = (2 * c[0] + PrNum_) * PrDen_;
605  double Cnm1 = 1;
606  double Cn = Pr;
607  double Cnp1;
608  for (size_t j = 0; j < nT_; j++) {
609  dotProd_[j] = chebCoeffs_[nP_*j] + Pr * chebCoeffs_[nP_*j+1];
610  }
611  for (size_t i = 2; i < nP_; i++) {
612  Cnp1 = 2 * Pr * Cn - Cnm1;
613  for (size_t j = 0; j < nT_; j++) {
614  dotProd_[j] += Cnp1 * chebCoeffs_[nP_*j + i];
615  }
616  Cnm1 = Cn;
617  Cn = Cnp1;
618  }
619  }
620 
621  /**
622  * Update the value of the base-10 logarithm of the rate constant.
623  */
624  doublereal update(doublereal logT, doublereal recipT) const {
625  double Tr = (2 * recipT + TrNum_) * TrDen_;
626  double Cnm1 = 1;
627  double Cn = Tr;
628  double Cnp1;
629  double logk = dotProd_[0] + Tr * dotProd_[1];
630  for (size_t i = 2; i < nT_; i++) {
631  Cnp1 = 2 * Tr * Cn - Cnm1;
632  logk += Cnp1 * dotProd_[i];
633  Cnm1 = Cn;
634  Cn = Cnp1;
635  }
636  return logk;
637  }
638 
639  /**
640  * Update the value the rate constant.
641  *
642  * This function returns the actual value of the rate constant.
643  */
644  doublereal updateRC(doublereal logT, doublereal recipT) const {
645  return std::pow(10, update(logT, recipT));
646  }
647 
648  doublereal activationEnergy_R() const {
649  return 0.0;
650  }
651 
652  static bool alwaysComputeRate() {
653  return false;
654  }
655 
656 protected:
657  double TrNum_, TrDen_; //!< terms appearing in the reduced temperature
658  double PrNum_, PrDen_; //!< terms appearing in the reduced pressure
659 
660  size_t nP_; //!< number of points in the pressure direction
661  size_t nT_; //!< number of points in the temperature direction
662  vector_fp chebCoeffs_; //!< Chebyshev coefficients, length nP * nT
663  vector_fp dotProd_; //!< dot product of chebCoeffs with the reduced pressure polynomial
664 };
665 
666 }
667 
668 #endif
669 
670 
void update_C(const doublereal *c)
Update concentration-dependent parts of the rate coefficient.
Definition: RxnRates.h:80
std::string int2str(const int n, const std::string &fmt)
Convert an int to a string using a format converter.
Definition: stringUtils.cpp:40
doublereal update(doublereal logT, doublereal recipT) const
Update the value of the logarithm of the rate constant.
Definition: RxnRates.h:228
vector_fp rateCoeffParameters
Vector of rate coefficient parameters.
Definition: ReactionData.h:91
Arrhenius()
Default constructor.
Definition: RxnRates.h:40
doublereal updateRC(doublereal logT, doublereal recipT) const
Update the value the rate constant.
Definition: RxnRates.h:342
#define AssertThrowMsg(expr, procedure, message)
Assertion must be true or an error is thrown.
Definition: ctexceptions.h:247
static int type()
return the rate coefficient type.
Definition: RxnRates.h:275
doublereal updateRC(doublereal logT, doublereal recipT) const
Update the value the rate constant.
Definition: RxnRates.h:240
ExchangeCurrent(doublereal A, doublereal b, doublereal E)
Constructor.
Definition: RxnRates.h:304
void update_C(const doublereal *c)
Update concentration-dependent parts of the rate coefficient.
Definition: RxnRates.h:320
std::string fp2str(const double x, const std::string &fmt)
Convert a double into a c++ string.
Definition: stringUtils.cpp:29
Arrhenius reaction rate type depends only on temperature.
Definition: RxnRates.h:270
This file defines some constants used to specify reaction types.
Intermediate class which stores data about a reaction and its rate parameterization before adding the...
Definition: ReactionData.h:16
Arrhenius reaction rate type depends only on temperature.
Definition: RxnRates.h:31
Arrhenius(doublereal A, doublereal b, doublereal E)
Constructor.
Definition: RxnRates.h:64
doublereal update(doublereal logT, doublereal recipT) const
Update the value of the logarithm of the rate constant.
Definition: RxnRates.h:331
std::vector< double > vector_fp
Turn on the use of stl vectors for the basic array type within cantera Vector of doubles.
Definition: ct_defs.h:165
const doublereal Tiny
Small number to compare differences of mole fractions against.
Definition: ct_defs.h:155
doublereal updateRC(doublereal logT, doublereal recipT) const
Update the value the rate constant.
Definition: RxnRates.h:102
Contains declarations for string manipulation functions within Cantera.
ExchangeCurrent(const ReactionData &rdata)
Constructor with Arrhenius parameters from a ReactionData struct.
Definition: RxnRates.h:287
ExchangeCurrent()
Default constructor.
Definition: RxnRates.h:280
Arrhenius(const ReactionData &rdata)
Constructor from ReactionData.
Definition: RxnRates.h:47
An Arrhenius rate with coverage-dependent terms.
Definition: RxnRates.h:145
static int type()
return the rate coefficient type.
Definition: RxnRates.h:35
Definitions for the classes that are thrown when Cantera experiences an error condition (also contain...
doublereal update(doublereal logT, doublereal recipT) const
Update the value of the logarithm of the rate constant.
Definition: RxnRates.h:91