Cantera  3.1.0a1
GasTransport.h
Go to the documentation of this file.
1 /**
2  * @file GasTransport.h
3  */
4 
5 // This file is part of Cantera. See License.txt in the top-level directory or
6 // at https://cantera.org/license.txt for license and copyright information.
7 
8 #ifndef CT_GAS_TRANSPORT_H
9 #define CT_GAS_TRANSPORT_H
10 
11 #include "Transport.h"
13 
14 namespace Cantera
15 {
16 
17 class MMCollisionInt;
18 
19 //! Class GasTransport implements some functions and properties that are
20 //! shared by the MixTransport and MultiTransport classes.
21 //!
22 //! For details, see Kee, et al. @cite kee2003 and @cite kee2017.
23 //!
24 //! @ingroup tranprops
25 class GasTransport : public Transport
26 {
27 public:
28  //! Viscosity of the mixture (kg /m /s)
29  /*!
30  * The viscosity is computed using the Wilke mixture rule (kg /m /s)
31  *
32  * @f[
33  * \mu = \sum_k \frac{\mu_k X_k}{\sum_j \Phi_{k,j} X_j}.
34  * @f]
35  *
36  * Here @f$ \mu_k @f$ is the viscosity of pure species @e k, and
37  *
38  * @f[
39  * \Phi_{k,j} = \frac{\left[1
40  * + \sqrt{\left(\frac{\mu_k}{\mu_j}\sqrt{\frac{M_j}{M_k}}\right)}\right]^2}
41  * {\sqrt{8}\sqrt{1 + M_k/M_j}}
42  * @f]
43  *
44  * @returns the viscosity of the mixture (units = Pa s = kg /m /s)
45  *
46  * @see updateViscosity_T()
47  */
48  double viscosity() override;
49 
50  //! Get the pure-species viscosities
51  void getSpeciesViscosities(double* const visc) override {
52  update_T();
54  std::copy(m_visc.begin(), m_visc.end(), visc);
55  }
56 
57  //! Returns the matrix of binary diffusion coefficients.
58  /*!
59  * d[ld*j + i] = rp * m_bdiff(i,j);
60  *
61  * @param ld offset of rows in the storage
62  * @param d output vector of diffusion coefficients. Units of m**2 / s
63  */
64  void getBinaryDiffCoeffs(const size_t ld, double* const d) override;
65 
66  //! Returns the Mixture-averaged diffusion coefficients [m^2/s].
67  /*!
68  * Returns the mixture averaged diffusion coefficients for a gas,
69  * appropriate for calculating the mass averaged diffusive flux with respect
70  * to the mass averaged velocity using gradients of the mole fraction.
71  * Note, for the single species case or the pure fluid case the routine
72  * returns the self-diffusion coefficient. This is needed to avoid a Nan
73  * result in the formula below.
74  *
75  * This is Eqn. 12.180 from "Chemically Reacting Flow"
76  *
77  * @f[
78  * D_{km}' = \frac{\left( \bar{M} - X_k M_k \right)}{ \bar{\qquad M \qquad } } {\left( \sum_{j \ne k} \frac{X_j}{D_{kj}} \right) }^{-1}
79  * @f]
80  *
81  * @param[out] d Vector of mixture diffusion coefficients, @f$ D_{km}' @f$ ,
82  * for each species (m^2/s). length m_nsp
83  */
84  void getMixDiffCoeffs(double* const d) override;
85 
86  //! Returns the mixture-averaged diffusion coefficients [m^2/s].
87  //! These are the coefficients for calculating the molar diffusive fluxes
88  //! from the species mole fraction gradients, computed according to
89  //! Eq. 12.176 in "Chemically Reacting Flow":
90  //!
91  //! @f[ D_{km}^* = \frac{1-X_k}{\sum_{j \ne k}^K X_j/\mathcal{D}_{kj}} @f]
92  //!
93  //! @param[out] d vector of mixture-averaged diffusion coefficients for
94  //! each species, length m_nsp.
95  void getMixDiffCoeffsMole(double* const d) override;
96 
97  //! Returns the mixture-averaged diffusion coefficients [m^2/s].
98  /*!
99  * These are the coefficients for calculating the diffusive mass fluxes
100  * from the species mass fraction gradients, computed according to
101  * Eq. 12.178 in "Chemically Reacting Flow":
102  *
103  * @f[
104  * \frac{1}{D_{km}} = \sum_{j \ne k}^K \frac{X_j}{\mathcal{D}_{kj}} +
105  * \frac{X_k}{1-Y_k} \sum_{j \ne k}^K \frac{Y_j}{\mathcal{D}_{kj}}
106  * @f]
107  *
108  * @param[out] d vector of mixture-averaged diffusion coefficients for
109  * each species, length m_nsp.
110  */
111  void getMixDiffCoeffsMass(double* const d) override;
112 
113  //! Return the polynomial fits to the viscosity of species i
114  //! @see fitProperties()
115  void getViscosityPolynomial(size_t i, double* coeffs) const override;
116 
117  //! Return the temperature fits of the heat conductivity of species i
118  //! @see fitProperties()
119  void getConductivityPolynomial(size_t i, double* coeffs) const override;
120 
121  //! Return the polynomial fits to the binary diffusivity of species pair (i, j)
122  //! @see fitDiffCoeffs()
123  void getBinDiffusivityPolynomial(size_t i, size_t j, double* coeffs) const override;
124 
125  //! Return the polynomial fits to the collision integral of species pair (i, j)
126  //! @see fitCollisionIntegrals()
127  void getCollisionIntegralPolynomial(size_t i, size_t j,
128  double* astar_coeffs,
129  double* bstar_coeffs,
130  double* cstar_coeffs) const override;
131 
132  //! Modify the polynomial fits to the viscosity of species i
133  //! @see fitProperties()
134  void setViscosityPolynomial(size_t i, double* coeffs) override;
135 
136  //! Modify the temperature fits of the heat conductivity of species i
137  //! @see fitProperties()
138  void setConductivityPolynomial(size_t i, double* coeffs) override;
139 
140  //! Modify the polynomial fits to the binary diffusivity of species pair (i, j)
141  //! @see fitDiffCoeffs()
142  void setBinDiffusivityPolynomial(size_t i, size_t j, double* coeffs) override;
143 
144  //! Modify the polynomial fits to the collision integral of species pair (i, j)
145  //! @see fitCollisionIntegrals()
146  void setCollisionIntegralPolynomial(size_t i, size_t j,
147  double* astar_coeffs,
148  double* bstar_coeffs,
149  double* cstar_coeffs, bool actualT) override;
150 
151  void init(ThermoPhase* thermo, int mode=0, int log_level=0) override;
152 
153  bool CKMode() const override {
154  return m_mode == CK_Mode;
155  }
156 
157 protected:
158  GasTransport();
159 
160  virtual void update_T();
161  virtual void update_C() = 0;
162 
163  //! Update the temperature-dependent viscosity terms.
164  /**
165  * Updates the array of pure species viscosities, and the weighting
166  * functions in the viscosity mixture rule. The flag m_visc_ok is set to true.
167  *
168  * The formula for the weighting function is from Poling et al. @cite poling2001,
169  * Eq. (9-5.14):
170  * @f[
171  * \phi_{ij} = \frac{ \left[ 1 + \left( \mu_i / \mu_j \right)^{1/2} \left( M_j / M_i \right)^{1/4} \right]^2 }
172  * {\left[ 8 \left( 1 + M_i / M_j \right) \right]^{1/2}}
173  * @f]
174  */
175  virtual void updateViscosity_T();
176 
177  //! Update the pure-species viscosities. These are evaluated from the
178  //! polynomial fits of the temperature and are assumed to be independent
179  //! of pressure.
180  virtual void updateSpeciesViscosities();
181 
182  //! Update the binary diffusion coefficients
183  /*!
184  * These are evaluated from the polynomial fits of the temperature at the
185  * unit pressure of 1 Pa.
186  */
187  virtual void updateDiff_T();
188 
189  //! @name Initialization
190  //! @{
191 
192  //! Setup parameters for a new kinetic-theory-based transport manager for
193  //! low-density gases
194  virtual void setupCollisionParameters();
195 
196  //! Setup range for polynomial fits to collision integrals of
197  //! Monchick & Mason @cite monchick1961
198  void setupCollisionIntegral();
199 
200  //! Read the transport database
201  /*!
202  * Read transport property data from a file for a list of species. Given the
203  * name of a file containing transport property parameters and a list of
204  * species names.
205  */
206  void getTransportData();
207 
208  //! Corrections for polar-nonpolar binary diffusion coefficients
209  /*!
210  * Calculate corrections to the well depth parameter and the diameter for use in
211  * computing the binary diffusion coefficient of polar-nonpolar pairs. For more
212  * information about this correction, see Dixon-Lewis @cite dixon-lewis1968.
213  *
214  * @param i Species one - this is a bimolecular correction routine
215  * @param j species two - this is a bimolecular correction routine
216  * @param f_eps Multiplicative correction factor to be applied to epsilon(i,j)
217  * @param f_sigma Multiplicative correction factor to be applied to diam(i,j)
218  */
219  void makePolarCorrections(size_t i, size_t j, double& f_eps,
220  double& f_sigma);
221 
222  //! Generate polynomial fits to collision integrals
223  /*!
224  * @param integrals interpolator for the collision integrals
225  */
226  void fitCollisionIntegrals(MMCollisionInt& integrals);
227 
228  //! Generate polynomial fits to the viscosity @f$ \eta @f$ and conductivity
229  //! @f$ \lambda @f$.
230  /*!
231  * If CK_mode, then the fits are of the form
232  * @f[
233  * \ln \eta(i) = \sum_{n=0}^3 a_n(i) \, (\ln T)^n
234  * @f]
235  * and
236  * @f[
237  * \ln \lambda(i) = \sum_{n=0}^3 b_n(i) \, (\ln T)^n
238  * @f]
239  * Otherwise the fits are of the form
240  * @f[
241  * \left(\eta(i)\right)^{1/2} = T^{1/4} \sum_{n=0}^4 a_n(i) \, (\ln T)^n
242  * @f]
243  * and
244  * @f[
245  * \lambda(i) = T^{1/2} \sum_{n=0}^4 b_n(i) \, (\ln T)^n
246  * @f]
247  *
248  * @param integrals interpolator for the collision integrals
249  */
250  virtual void fitProperties(MMCollisionInt& integrals);
251 
252  //! Generate polynomial fits to the binary diffusion coefficients
253  /*!
254  * If CK_mode, then the fits are of the form
255  * @f[
256  * \ln D(i,j) = \sum_{n=0}^3 c_n(i,j) \, (\ln T)^n
257  * @f]
258  * Otherwise the fits are of the form
259  * @f[
260  * D(i,j) = T^{3/2} \sum_{n=0}^4 c_n(i,j) \, (\ln T)^n
261  * @f]
262  *
263  * @param integrals interpolator for the collision integrals
264  */
265  virtual void fitDiffCoeffs(MMCollisionInt& integrals);
266 
267  //! Second-order correction to the binary diffusion coefficients
268  /*!
269  * Calculate second-order corrections to binary diffusion coefficient pair
270  * (dkj, djk). At first order, the binary diffusion coefficients are
271  * independent of composition, and d(k,j) = d(j,k). But at second order,
272  * there is a weak dependence on composition, with the result that d(k,j) !=
273  * d(j,k). This method computes the multiplier by which the first-order
274  * binary diffusion coefficient should be multiplied to produce the value
275  * correct to second order. The expressions here are taken from Marerro and
276  * Mason @cite marrero1972.
277  *
278  * @param t Temperature (K)
279  * @param integrals interpolator for the collision integrals
280  * @param k index of first species
281  * @param j index of second species
282  * @param xk Mole fraction of species k
283  * @param xj Mole fraction of species j
284  * @param fkj multiplier for d(k,j)
285  * @param fjk multiplier for d(j,k)
286  *
287  * @note This method is not used currently.
288  */
289  void getBinDiffCorrection(double t, MMCollisionInt& integrals, size_t k,
290  size_t j, double xk, double xj,
291  double& fkj, double& fjk);
292 
293  //! @}
294 
295  //! Vector of species mole fractions. These are processed so that all mole
296  //! fractions are >= *Tiny*. Length = m_kk.
297  vector<double> m_molefracs;
298 
299  //! Internal storage for the viscosity of the mixture (kg /m /s)
300  double m_viscmix = 0.0;
301 
302  //! Update boolean for mixture rule for the mixture viscosity
303  bool m_visc_ok = false;
304 
305  //! Update boolean for the weighting factors for the mixture viscosity
306  bool m_viscwt_ok = false;
307 
308  //! Update boolean for the species viscosities
309  bool m_spvisc_ok = false;
310 
311  //! Update boolean for the binary diffusivities at unit pressure
312  bool m_bindiff_ok = false;
313 
314  //! Type of the polynomial fits to temperature. `CK_Mode` means Chemkin mode.
315  //! Any other value means to use %Cantera's preferred fitting functions.
316  int m_mode = 0;
317 
318  //! m_phi is a Viscosity Weighting Function. size = m_nsp * n_nsp
320 
321  //! work space length = m_kk
322  vector<double> m_spwork;
323 
324  //! vector of species viscosities (kg /m /s). These are used in Wilke's
325  //! rule to calculate the viscosity of the solution. length = m_kk.
326  vector<double> m_visc;
327 
328  //! Polynomial fits to the viscosity of each species. m_visccoeffs[k] is
329  //! the vector of polynomial coefficients for species k that fits the
330  //! viscosity as a function of temperature.
331  vector<vector<double>> m_visccoeffs;
332 
333  //! Local copy of the species molecular weights.
334  vector<double> m_mw;
335 
336  //! Holds square roots of molecular weight ratios
337  /*!
338  * @code
339  * m_wratjk(j,k) = sqrt(mw[j]/mw[k]) j < k
340  * m_wratjk(k,j) = sqrt(sqrt(mw[j]/mw[k])) j < k
341  * @endcode
342  */
344 
345  //! Holds square roots of molecular weight ratios
346  /*!
347  * `m_wratjk1(j,k) = sqrt(1.0 + mw[k]/mw[j]) j < k`
348  */
350 
351  //! vector of square root of species viscosities sqrt(kg /m /s). These are
352  //! used in Wilke's rule to calculate the viscosity of the solution.
353  //! length = m_kk.
354  vector<double> m_sqvisc;
355 
356  //! Powers of the ln temperature, up to fourth order
357  vector<double> m_polytempvec;
358 
359  //! Current value of the temperature at which the properties in this object
360  //! are calculated (Kelvin).
361  double m_temp = -1.0;
362 
363  //! Current value of Boltzmann constant times the temperature (Joules)
364  double m_kbt = 0.0;
365 
366  //! current value of temperature to 1/2 power
367  double m_sqrt_t = 0.0;
368 
369  //! Current value of the log of the temperature
370  double m_logt = 0.0;
371 
372  //! Current value of temperature to 1/4 power
373  double m_t14 = 0.0;
374 
375  //! Polynomial fits to the binary diffusivity of each species
376  /*!
377  * m_diffcoeff[ic] is vector of polynomial coefficients for species i
378  * species j that fits the binary diffusion coefficient. The relationship
379  * between i j and ic is determined from the following algorithm:
380  *
381  * int ic = 0;
382  * for (i = 0; i < m_nsp; i++) {
383  * for (j = i; j < m_nsp; j++) {
384  * ic++;
385  * }
386  * }
387  */
388  vector<vector<double>> m_diffcoeffs;
389 
390  //! Matrix of binary diffusion coefficients at the reference pressure and
391  //! the current temperature Size is nsp x nsp.
393 
394  //! temperature fits of the heat conduction
395  /*!
396  * Dimensions are number of species (nsp) polynomial order of the collision
397  * integral fit (degree+1).
398  */
399  vector<vector<double>> m_condcoeffs;
400 
401  //! Indices for the (i,j) interaction in collision integral fits
402  /*!
403  * m_poly[i][j] contains the index for (i,j) interactions in
404  * #m_omega22_poly, #m_astar_poly, #m_bstar_poly, and #m_cstar_poly.
405  */
406  vector<vector<int>> m_poly;
407 
408  //! Fit for omega22 collision integral
409  /*!
410  * m_omega22_poly[m_poly[i][j]] is the vector of polynomial coefficients
411  * (length degree+1) for the collision integral fit for the species pair
412  * (i,j).
413  */
414  vector<vector<double>> m_omega22_poly;
415 
416  //! Flag to indicate for which (i,j) interaction pairs the
417  //! actual temperature is used instead of the reduced temperature
418  vector<vector<int>> m_star_poly_uses_actualT;
419 
420  //! Fit for astar collision integral
421  /*!
422  * m_astar_poly[m_poly[i][j]] is the vector of polynomial coefficients
423  * (length degree+1) for the collision integral fit for the species pair
424  * (i,j).
425  */
426  vector<vector<double>> m_astar_poly;
427 
428  //! Fit for bstar collision integral
429  /*!
430  * m_bstar_poly[m_poly[i][j]] is the vector of polynomial coefficients
431  * (length degree+1) for the collision integral fit for the species pair
432  * (i,j).
433  */
434  vector<vector<double>> m_bstar_poly;
435 
436  //! Fit for cstar collision integral
437  /*!
438  * m_bstar_poly[m_poly[i][j]] is the vector of polynomial coefficients
439  * (length degree+1) for the collision integral fit for the species pair
440  * (i,j).
441  */
442  vector<vector<double>> m_cstar_poly;
443 
444  //! Rotational relaxation number for each species
445  /*!
446  * length is the number of species in the phase. units are dimensionless
447  */
448  vector<double> m_zrot;
449 
450  //! Dimensionless rotational heat capacity of each species
451  /*!
452  * These values are 0, 1 and 1.5 for single-molecule, linear, and nonlinear
453  * species respectively length is the number of species in the phase.
454  * Dimensionless (Cr / R)
455  */
456  vector<double> m_crot;
457 
458  //! Vector of booleans indicating whether a species is a polar molecule
459  /*!
460  * Length is nsp
461  */
462  vector<bool> m_polar;
463 
464  //! Polarizability of each species in the phase
465  /*!
466  * Length = nsp. Units = m^3
467  */
468  vector<double> m_alpha;
469 
470  //! Lennard-Jones well-depth of the species in the current phase
471  /*!
472  * length is the number of species in the phase. Units are Joules (Note this
473  * is not Joules/kmol) (note, no kmol -> this is a per molecule amount)
474  */
475  vector<double> m_eps;
476 
477  //! Lennard-Jones diameter of the species in the current phase
478  /*!
479  * length is the number of species in the phase. units are in meters.
480  */
481  vector<double> m_sigma;
482 
483  //! This is the reduced mass of the interaction between species i and j
484  /*!
485  * reducedMass(i,j) = mw[i] * mw[j] / (Avogadro * (mw[i] + mw[j]));
486  *
487  * Units are kg (note, no kmol -> this is a per molecule amount)
488  *
489  * Length nsp * nsp. This is a symmetric matrix
490  */
492 
493  //! hard-sphere diameter for (i,j) collision
494  /*!
495  * diam(i,j) = 0.5*(sigma[i] + sigma[j]);
496  * Units are m (note, no kmol -> this is a per molecule amount)
497  *
498  * Length nsp * nsp. This is a symmetric matrix.
499  */
501 
502  //! The effective well depth for (i,j) collisions
503  /*!
504  * epsilon(i,j) = sqrt(eps[i]*eps[j]);
505  * Units are Joules (note, no kmol -> this is a per molecule amount)
506  *
507  * Length nsp * nsp. This is a symmetric matrix.
508  */
510 
511  //! The effective dipole moment for (i,j) collisions
512  /*!
513  * Given `dipoleMoment` in Debye (a Debye is 3.335e-30 C-m):
514  *
515  * dipole(i,i) = 1.e-21 / lightSpeed * dipoleMoment;
516  * dipole(i,j) = sqrt(dipole(i,i) * dipole(j,j));
517  * (note, no kmol -> this is a per molecule amount)
518  *
519  * Length nsp * nsp. This is a symmetric matrix.
520  */
522 
523  //! Reduced dipole moment of the interaction between two species
524  /*!
525  * This is the reduced dipole moment of the interaction between two species
526  * 0.5 * dipole(i,j)^2 / (4 * Pi * epsilon_0 * epsilon(i,j) * d^3);
527  *
528  * Length nsp * nsp .This is a symmetric matrix
529  */
531 
532  //! Pitzer acentric factor
533  /*!
534  * Length is the number of species in the phase. Dimensionless.
535  */
536  vector<double> m_w_ac;
537 
538  //! Dispersion coefficient
539  vector<double> m_disp;
540 
541  //! Quadrupole polarizability
542  vector<double> m_quad_polar;
543 
544  //! Level of verbose printing during initialization
545  int m_log_level = 0;
546 };
547 
548 } // namespace Cantera
549 
550 #endif
Headers for the DenseMatrix object, which deals with dense rectangular matrices and description of th...
Headers for the Transport object, which is the virtual base class for all transport property evaluato...
A class for full (non-sparse) matrices with Fortran-compatible data storage, which adds matrix operat...
Definition: DenseMatrix.h:55
Class GasTransport implements some functions and properties that are shared by the MixTransport and M...
Definition: GasTransport.h:26
vector< bool > m_polar
Vector of booleans indicating whether a species is a polar molecule.
Definition: GasTransport.h:462
void getTransportData()
Read the transport database.
virtual void setupCollisionParameters()
Setup parameters for a new kinetic-theory-based transport manager for low-density gases.
double m_t14
Current value of temperature to 1/4 power.
Definition: GasTransport.h:373
vector< double > m_mw
Local copy of the species molecular weights.
Definition: GasTransport.h:334
vector< double > m_molefracs
Vector of species mole fractions.
Definition: GasTransport.h:297
void getBinaryDiffCoeffs(const size_t ld, double *const d) override
Returns the matrix of binary diffusion coefficients.
vector< double > m_quad_polar
Quadrupole polarizability.
Definition: GasTransport.h:542
void setCollisionIntegralPolynomial(size_t i, size_t j, double *astar_coeffs, double *bstar_coeffs, double *cstar_coeffs, bool actualT) override
Modify the polynomial fits to the collision integral of species pair (i, j)
void getCollisionIntegralPolynomial(size_t i, size_t j, double *astar_coeffs, double *bstar_coeffs, double *cstar_coeffs) const override
Return the polynomial fits to the collision integral of species pair (i, j)
void setBinDiffusivityPolynomial(size_t i, size_t j, double *coeffs) override
Modify the polynomial fits to the binary diffusivity of species pair (i, j)
double m_temp
Current value of the temperature at which the properties in this object are calculated (Kelvin).
Definition: GasTransport.h:361
virtual void fitProperties(MMCollisionInt &integrals)
Generate polynomial fits to the viscosity and conductivity .
vector< vector< double > > m_visccoeffs
Polynomial fits to the viscosity of each species.
Definition: GasTransport.h:331
bool m_visc_ok
Update boolean for mixture rule for the mixture viscosity.
Definition: GasTransport.h:303
DenseMatrix m_wratkj1
Holds square roots of molecular weight ratios.
Definition: GasTransport.h:349
void getMixDiffCoeffs(double *const d) override
Returns the Mixture-averaged diffusion coefficients [m^2/s].
void getSpeciesViscosities(double *const visc) override
Get the pure-species viscosities.
Definition: GasTransport.h:51
virtual void fitDiffCoeffs(MMCollisionInt &integrals)
Generate polynomial fits to the binary diffusion coefficients.
vector< double > m_disp
Dispersion coefficient.
Definition: GasTransport.h:539
vector< double > m_eps
Lennard-Jones well-depth of the species in the current phase.
Definition: GasTransport.h:475
virtual void updateDiff_T()
Update the binary diffusion coefficients.
vector< double > m_sqvisc
vector of square root of species viscosities sqrt(kg /m /s).
Definition: GasTransport.h:354
DenseMatrix m_wratjk
Holds square roots of molecular weight ratios.
Definition: GasTransport.h:343
bool m_bindiff_ok
Update boolean for the binary diffusivities at unit pressure.
Definition: GasTransport.h:312
DenseMatrix m_epsilon
The effective well depth for (i,j) collisions.
Definition: GasTransport.h:509
void getBinDiffusivityPolynomial(size_t i, size_t j, double *coeffs) const override
Return the polynomial fits to the binary diffusivity of species pair (i, j)
DenseMatrix m_diam
hard-sphere diameter for (i,j) collision
Definition: GasTransport.h:500
void getMixDiffCoeffsMole(double *const d) override
Returns the mixture-averaged diffusion coefficients [m^2/s].
vector< double > m_spwork
work space length = m_kk
Definition: GasTransport.h:322
vector< double > m_zrot
Rotational relaxation number for each species.
Definition: GasTransport.h:448
int m_mode
Type of the polynomial fits to temperature.
Definition: GasTransport.h:316
bool CKMode() const override
Boolean indicating the form of the transport properties polynomial fits.
Definition: GasTransport.h:153
double m_logt
Current value of the log of the temperature.
Definition: GasTransport.h:370
void getViscosityPolynomial(size_t i, double *coeffs) const override
Return the polynomial fits to the viscosity of species i.
void fitCollisionIntegrals(MMCollisionInt &integrals)
Generate polynomial fits to collision integrals.
virtual void updateViscosity_T()
Update the temperature-dependent viscosity terms.
double m_viscmix
Internal storage for the viscosity of the mixture (kg /m /s)
Definition: GasTransport.h:300
vector< double > m_sigma
Lennard-Jones diameter of the species in the current phase.
Definition: GasTransport.h:481
bool m_spvisc_ok
Update boolean for the species viscosities.
Definition: GasTransport.h:309
vector< double > m_visc
vector of species viscosities (kg /m /s).
Definition: GasTransport.h:326
virtual void updateSpeciesViscosities()
Update the pure-species viscosities.
double m_sqrt_t
current value of temperature to 1/2 power
Definition: GasTransport.h:367
DenseMatrix m_bdiff
Matrix of binary diffusion coefficients at the reference pressure and the current temperature Size is...
Definition: GasTransport.h:392
vector< vector< double > > m_omega22_poly
Fit for omega22 collision integral.
Definition: GasTransport.h:414
vector< double > m_polytempvec
Powers of the ln temperature, up to fourth order.
Definition: GasTransport.h:357
DenseMatrix m_dipole
The effective dipole moment for (i,j) collisions.
Definition: GasTransport.h:521
vector< double > m_crot
Dimensionless rotational heat capacity of each species.
Definition: GasTransport.h:456
vector< vector< double > > m_diffcoeffs
Polynomial fits to the binary diffusivity of each species.
Definition: GasTransport.h:388
void getConductivityPolynomial(size_t i, double *coeffs) const override
Return the temperature fits of the heat conductivity of species i.
void setViscosityPolynomial(size_t i, double *coeffs) override
Modify the polynomial fits to the viscosity of species i.
double m_kbt
Current value of Boltzmann constant times the temperature (Joules)
Definition: GasTransport.h:364
DenseMatrix m_reducedMass
This is the reduced mass of the interaction between species i and j.
Definition: GasTransport.h:491
int m_log_level
Level of verbose printing during initialization.
Definition: GasTransport.h:545
vector< vector< int > > m_star_poly_uses_actualT
Flag to indicate for which (i,j) interaction pairs the actual temperature is used instead of the redu...
Definition: GasTransport.h:418
double viscosity() override
Viscosity of the mixture (kg /m /s)
vector< double > m_w_ac
Pitzer acentric factor.
Definition: GasTransport.h:536
vector< vector< double > > m_bstar_poly
Fit for bstar collision integral.
Definition: GasTransport.h:434
vector< vector< double > > m_astar_poly
Fit for astar collision integral.
Definition: GasTransport.h:426
vector< vector< int > > m_poly
Indices for the (i,j) interaction in collision integral fits.
Definition: GasTransport.h:406
vector< vector< double > > m_condcoeffs
temperature fits of the heat conduction
Definition: GasTransport.h:399
bool m_viscwt_ok
Update boolean for the weighting factors for the mixture viscosity.
Definition: GasTransport.h:306
vector< vector< double > > m_cstar_poly
Fit for cstar collision integral.
Definition: GasTransport.h:442
vector< double > m_alpha
Polarizability of each species in the phase.
Definition: GasTransport.h:468
DenseMatrix m_delta
Reduced dipole moment of the interaction between two species.
Definition: GasTransport.h:530
DenseMatrix m_phi
m_phi is a Viscosity Weighting Function. size = m_nsp * n_nsp
Definition: GasTransport.h:319
void setupCollisionIntegral()
Setup range for polynomial fits to collision integrals of Monchick & Mason .
void setConductivityPolynomial(size_t i, double *coeffs) override
Modify the temperature fits of the heat conductivity of species i.
void init(ThermoPhase *thermo, int mode=0, int log_level=0) override
Initialize a transport manager.
void makePolarCorrections(size_t i, size_t j, double &f_eps, double &f_sigma)
Corrections for polar-nonpolar binary diffusion coefficients.
void getBinDiffCorrection(double t, MMCollisionInt &integrals, size_t k, size_t j, double xk, double xj, double &fkj, double &fjk)
Second-order correction to the binary diffusion coefficients.
void getMixDiffCoeffsMass(double *const d) override
Returns the mixture-averaged diffusion coefficients [m^2/s].
Calculation of Collision integrals.
Base class for a phase with thermodynamic properties.
Definition: ThermoPhase.h:390
Base class for transport property managers.
Definition: Transport.h:72
ThermoPhase & thermo()
Phase object.
Definition: Transport.h:103
Namespace for the Cantera kernel.
Definition: AnyMap.cpp:564