Cantera  3.1.0a1
Loading...
Searching...
No Matches
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
14namespace Cantera
15{
16
17class 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
25class GasTransport : public Transport
26{
27public:
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
157protected:
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
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...
vector< bool > m_polar
Vector of booleans indicating whether a species is a polar molecule.
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.
vector< double > m_mw
Local copy of the species molecular weights.
vector< double > m_molefracs
Vector of species mole fractions.
void getBinaryDiffCoeffs(const size_t ld, double *const d) override
Returns the matrix of binary diffusion coefficients.
vector< double > m_quad_polar
Quadrupole polarizability.
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).
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.
bool m_visc_ok
Update boolean for mixture rule for the mixture viscosity.
DenseMatrix m_wratkj1
Holds square roots of molecular weight ratios.
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.
virtual void fitDiffCoeffs(MMCollisionInt &integrals)
Generate polynomial fits to the binary diffusion coefficients.
vector< double > m_disp
Dispersion coefficient.
vector< double > m_eps
Lennard-Jones well-depth of the species in the current phase.
virtual void updateDiff_T()
Update the binary diffusion coefficients.
vector< double > m_sqvisc
vector of square root of species viscosities sqrt(kg /m /s).
DenseMatrix m_wratjk
Holds square roots of molecular weight ratios.
bool m_bindiff_ok
Update boolean for the binary diffusivities at unit pressure.
DenseMatrix m_epsilon
The effective well depth for (i,j) collisions.
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
void getMixDiffCoeffsMole(double *const d) override
Returns the mixture-averaged diffusion coefficients [m^2/s].
vector< double > m_spwork
work space length = m_kk
vector< double > m_zrot
Rotational relaxation number for each species.
int m_mode
Type of the polynomial fits to temperature.
bool CKMode() const override
Boolean indicating the form of the transport properties polynomial fits.
double m_logt
Current value of the log of the temperature.
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)
vector< double > m_sigma
Lennard-Jones diameter of the species in the current phase.
bool m_spvisc_ok
Update boolean for the species viscosities.
vector< double > m_visc
vector of species viscosities (kg /m /s).
virtual void updateSpeciesViscosities()
Update the pure-species viscosities.
double m_sqrt_t
current value of temperature to 1/2 power
DenseMatrix m_bdiff
Matrix of binary diffusion coefficients at the reference pressure and the current temperature Size is...
vector< vector< double > > m_omega22_poly
Fit for omega22 collision integral.
vector< double > m_polytempvec
Powers of the ln temperature, up to fourth order.
DenseMatrix m_dipole
The effective dipole moment for (i,j) collisions.
vector< double > m_crot
Dimensionless rotational heat capacity of each species.
vector< vector< double > > m_diffcoeffs
Polynomial fits to the binary diffusivity of each species.
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)
DenseMatrix m_reducedMass
This is the reduced mass of the interaction between species i and j.
int m_log_level
Level of verbose printing during initialization.
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...
double viscosity() override
Viscosity of the mixture (kg /m /s)
vector< double > m_w_ac
Pitzer acentric factor.
vector< vector< double > > m_bstar_poly
Fit for bstar collision integral.
vector< vector< double > > m_astar_poly
Fit for astar collision integral.
vector< vector< int > > m_poly
Indices for the (i,j) interaction in collision integral fits.
vector< vector< double > > m_condcoeffs
temperature fits of the heat conduction
bool m_viscwt_ok
Update boolean for the weighting factors for the mixture viscosity.
vector< vector< double > > m_cstar_poly
Fit for cstar collision integral.
vector< double > m_alpha
Polarizability of each species in the phase.
DenseMatrix m_delta
Reduced dipole moment of the interaction between two species.
DenseMatrix m_phi
m_phi is a Viscosity Weighting Function. size = m_nsp * n_nsp
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.
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