Cantera  3.2.0a2
Loading...
Searching...
No Matches
Transport.h
Go to the documentation of this file.
1/**
2 * @file Transport.h Headers for the Transport object, which is the virtual
3 * base class for all transport property evaluators and also includes the
4 * tranprops group definition (see @ref tranprops and @link
5 * Cantera::Transport Transport @endlink) .
6 */
7
8// This file is part of Cantera. See License.txt in the top-level directory or
9// at https://cantera.org/license.txt for license and copyright information.
10
11/**
12 * @defgroup tranprops Transport Properties
13 *
14 * These classes provide transport properties, including diffusion coefficients,
15 * thermal conductivity, and viscosity.
16 */
17
18#ifndef CT_TRANSPORT_H
19#define CT_TRANSPORT_H
20
23#include "cantera/base/AnyMap.h"
24
25namespace Cantera
26{
27
28class ThermoPhase;
29
30/**
31 * @addtogroup tranprops
32 */
33//! @cond
34
35const int CK_Mode = 10;
36
37//! @endcond
38
39//! Base class for transport property managers.
40/*!
41 * All classes that compute transport properties for a single phase derive from
42 * this class. Class Transport is meant to be used as a base class only. It is
43 * possible to instantiate it, but its methods throw exceptions if called.
44 *
45 * ## Relationship of the Transport class to the ThermoPhase Class
46 *
47 * This section describes how calculations are carried out within the Transport
48 * class. The Transport class and derived classes of the the Transport class
49 * necessarily use the ThermoPhase class to obtain the list of species and the
50 * thermodynamic state of the phase.
51 *
52 * No state information is stored within Transport classes. Queries to the
53 * underlying ThermoPhase object must be made to obtain the state of the system.
54 *
55 * An exception to this however is the state information concerning the the
56 * gradients of variables. This information is not stored within the ThermoPhase
57 * objects. It may be collected within the Transport objects. In fact, the
58 * meaning of const operations within the Transport class refers to calculations
59 * which do not change the state of the system nor the state of the first order
60 * gradients of the system.
61 *
62 * When a const operation is evoked within the Transport class, it is also
63 * implicitly assumed that the underlying state within the ThermoPhase object
64 * has not changed its values.
65 *
66 * @todo Provide a general mechanism to store the gradients of state variables
67 * within the system.
68 *
69 * @ingroup tranprops
70 */
72{
73public:
74 //! Constructor.
75 /*!
76 * New transport managers should be created using TransportFactory, not by
77 * calling the constructor directly.
78 *
79 * @see TransportFactory
80 */
81 Transport() = default;
82
83 virtual ~Transport() {}
84
85 // Transport objects are not copyable or assignable
86 Transport(const Transport&) = delete;
87 Transport& operator=(const Transport&) = delete;
88
89 //! Identifies the model represented by this Transport object. Each derived class
90 //! should override this method to return a meaningful identifier.
91 //! @since New in %Cantera 3.0. The name returned by this method corresponds
92 //! to the canonical name used in the YAML input format.
93 virtual string transportModel() const {
94 return "none";
95 }
96
97 /**
98 * Phase object. Every transport manager is designed to compute properties
99 * for a specific phase of a mixture, which might be a liquid solution, a
100 * gas mixture, a surface, etc. This method returns a reference to the
101 * object representing the phase itself.
102 */
104 return *m_thermo;
105 }
106
107 //! Check that the specified species index is in range. Throws an exception
108 //! if k is greater than #m_nsp.
109 void checkSpeciesIndex(size_t k) const;
110
111 //! Check that an array size is at least #m_nsp. Throws an exception if
112 //! kk is less than #m_nsp. Used before calls which take an array
113 //! pointer.
114 void checkSpeciesArraySize(size_t kk) const;
115
116 //! @name Transport Properties
117 //! @{
118
119 //! Get the dynamic viscosity [Pa·s]
120 virtual double viscosity() {
121 throw NotImplementedError("Transport::viscosity",
122 "Not implemented for transport model '{}'.", transportModel());
123 }
124
125 //! Get the pure species viscosities [Pa·s].
126 /*!
127 * @param visc Vector of viscosities; length is the number of species
128 */
129 virtual void getSpeciesViscosities(double* const visc) {
130 throw NotImplementedError("Transport::getSpeciesViscosities",
131 "Not implemented for transport model '{}'.", transportModel());
132 }
133
134 //! The bulk viscosity [Pa·s].
135 /*!
136 * The bulk viscosity is only non-zero in rare cases. Most transport
137 * managers either overload this method to return zero, or do not implement
138 * it, in which case an exception is thrown if called.
139 */
140 virtual double bulkViscosity() {
141 throw NotImplementedError("Transport::bulkViscosity",
142 "Not implemented for transport model '{}'.", transportModel());
143 }
144
145 //! Get the mixture thermal conductivity [W/m/K].
146 virtual double thermalConductivity() {
147 throw NotImplementedError("Transport::thermalConductivity",
148 "Not implemented for transport model '{}'.", transportModel());
149 }
150
151 //! Get the electrical conductivity [siemens/m].
152 virtual double electricalConductivity() {
153 throw NotImplementedError("Transport::electricalConductivity",
154 "Not implemented for transport model '{}'.", transportModel());
155 }
156
157 //! Get the electrical mobilities [m²/V/s].
158 /*!
159 * This function returns the mobilities. In some formulations this is equal
160 * to the normal mobility multiplied by Faraday's constant.
161 *
162 * Frequently, but not always, the mobility is calculated from the diffusion
163 * coefficient using the Einstein relation
164 *
165 * @f[
166 * \mu^e_k = \frac{F D_k}{R T}
167 * @f]
168 *
169 * @param mobil_e Returns the mobilities of the species in array @c
170 * mobil_e. The array must be dimensioned at least as large as
171 * the number of species.
172 */
173 virtual void getMobilities(double* const mobil_e) {
174 throw NotImplementedError("Transport::getMobilities",
175 "Not implemented for transport model '{}'.", transportModel());
176 }
177
178 //! @}
179
180 //! Get the species diffusive mass fluxes [kg/m²/s] with respect to the specified
181 //! solution averaged velocity, given the mole fraction and temperature gradients.
182 /*!
183 * Usually the specified solution average velocity is the mass averaged velocity.
184 * This is changed in some subclasses, however.
185 *
186 * @param ndim Number of dimensions in the flux expressions
187 * @param[in] grad_T Gradient of the temperature (length `ndim`)
188 * @param ldx Leading dimension of the `grad_X` array (usually equal to the number
189 * of species)
190 * @param[in] grad_X Gradients of the mole fractions; flattened matrix such that
191 * @f$ dX_k/dx_n = \tt{ grad\_X[n*ldx+k]} @f$ is the gradient of species *k*
192 * in dimension *n*. Length is `ldx` * `ndim`.
193 * @param ldf Leading dimension of the `fluxes` array (usually equal to the number
194 * of species)
195 * @param[out] fluxes The diffusive mass fluxes; flattened matrix such that
196 * @f$ j_{kn} = \tt{ fluxes[n*ldf+k]} @f$ is the flux of species *k*
197 * in dimension *n*. Length is `ldf` * `ndim`.
198 */
199 virtual void getSpeciesFluxes(size_t ndim, const double* const grad_T,
200 size_t ldx, const double* const grad_X,
201 size_t ldf, double* const fluxes) {
202 throw NotImplementedError("Transport::getSpeciesFluxes",
203 "Not implemented for transport model '{}'.", transportModel());
204 }
205
206 //! Get the molar fluxes [kmol/m²/s], given the thermodynamic state at two
207 //! nearby points.
208 /*!
209 * @param[in] state1 Array of temperature, density, and mass fractions for
210 * state 1.
211 * @param[in] state2 Array of temperature, density, and mass fractions for
212 * state 2.
213 * @param[in] delta Distance [m] from state 1 to state 2.
214 * @param[out] cfluxes Array containing the diffusive molar fluxes of species from
215 * `state1` to `state2`; Length is number of species.
216 */
217 virtual void getMolarFluxes(const double* const state1,
218 const double* const state2, const double delta,
219 double* const cfluxes) {
220 throw NotImplementedError("Transport::getMolarFluxes",
221 "Not implemented for transport model '{}'.", transportModel());
222 }
223
224 //! Get the mass fluxes [kg/m²/s], given the thermodynamic state at two
225 //! nearby points.
226 /*!
227 * @param[in] state1 Array of temperature, density, and mass
228 * fractions for state 1.
229 * @param[in] state2 Array of temperature, density, and mass fractions for
230 * state 2.
231 * @param[in] delta Distance [m] from state 1 to state 2.
232 * @param[out] mfluxes Array containing the diffusive mass fluxes of species from
233 * `state1` to `state2`; length is number of species.
234 */
235 virtual void getMassFluxes(const double* state1,
236 const double* state2, double delta,
237 double* mfluxes) {
238 throw NotImplementedError("Transport::getMassFluxes",
239 "Not implemented for transport model '{}'.", transportModel());
240 }
241
242 //! Return a vector of thermal diffusion coefficients [kg/m/s].
243 /*!
244 * The thermal diffusion coefficient @f$ D^T_k @f$ is defined so that the
245 * diffusive mass flux of species *k* induced by the local temperature
246 * gradient is given by:
247 *
248 * @f[
249 * \mathbf{j}_k = -D^T_k \frac{\nabla T}{T}.
250 * @f]
251 *
252 * The thermal diffusion coefficient can be either positive or negative.
253 *
254 * @param dt On return, dt will contain the species thermal diffusion coefficients.
255 * Dimension dt at least as large as the number of species.
256 */
257 virtual void getThermalDiffCoeffs(double* const dt) {
258 throw NotImplementedError("Transport::getThermalDiffCoeffs",
259 "Not implemented for transport model '{}'.", transportModel());
260 }
261
262 //! Returns the matrix of binary diffusion coefficients [m²/s].
263 /*!
264 * @param[in] ld Leading dimension of the flattened array `d` used to store the
265 * diffusion coefficient matrix; usually equal to the number of
266 * species.
267 * @param[out] d Diffusion coefficient matrix stored in column-major (Fortran)
268 * order, such that @f$ \mathcal{D}_{ij} = \tt{d[ld*j + i]} @f$; must
269 * be at least `ld` times the number of species in length.
270 * @see GasTransport::fitDiffCoeffs()
271 */
272 virtual void getBinaryDiffCoeffs(const size_t ld, double* const d) {
273 throw NotImplementedError("Transport::getBinaryDiffCoeffs",
274 "Not implemented for transport model '{}'.", transportModel());
275 }
276
277 //! Return the multicomponent diffusion coefficients [m²/s].
278 /*!
279 * If the transport manager implements a multicomponent diffusion
280 * model, then this method returns the array of multicomponent
281 * diffusion coefficients. Otherwise it throws an exception.
282 *
283 * @param[in] ld Leading dimension of the flattened array `d` used to store the
284 * diffusion coefficient matrix; usually equal to the number of
285 * species.
286 * @param[out] d Diffusion coefficient matrix stored in column-major (Fortran)
287 * order, such that @f$ D_{ij} = \tt{d[ld*j + i]} @f$ is the
288 * diffusion coefficient for species *i* due to concentration
289 * gradients in species *j*; must be at least `ld` times the number
290 * of species in length.
291 */
292 virtual void getMultiDiffCoeffs(const size_t ld, double* const d) {
293 throw NotImplementedError("Transport::getMultiDiffCoeffs",
294 "Not implemented for transport model '{}'.", transportModel());
295 }
296
297 //! Return a vector of mixture averaged diffusion coefficients [m²/s].
298 /**
299 * Mixture-averaged diffusion coefficients [m^2/s]. If the transport
300 * manager implements a mixture-averaged diffusion model, then this method
301 * returns the array of mixture-averaged diffusion coefficients. Otherwise
302 * it throws an exception.
303 *
304 * @param d Return vector of mixture averaged diffusion coefficients; length is
305 * the number of species.
306 */
307 virtual void getMixDiffCoeffs(double* const d) {
308 throw NotImplementedError("Transport::getMixDiffCoeffs",
309 "Not implemented for transport model '{}'.", transportModel());
310 }
311
312 //! Returns a vector of mixture averaged diffusion coefficients [m²/s].
313 virtual void getMixDiffCoeffsMole(double* const d) {
314 throw NotImplementedError("Transport::getMixDiffCoeffsMole",
315 "Not implemented for transport model '{}'.", transportModel());
316 }
317
318 //! Returns a vector of mixture averaged diffusion coefficients [m²/s].
319 virtual void getMixDiffCoeffsMass(double* const d) {
320 throw NotImplementedError("Transport::getMixDiffCoeffsMass",
321 "Not implemented for transport model '{}'.", transportModel());
322 }
323
324 //! Return the polynomial fits to the viscosity of species `i`.
325 virtual void getViscosityPolynomial(size_t i, double* coeffs) const{
326 throw NotImplementedError("Transport::getViscosityPolynomial",
327 "Not implemented for transport model '{}'.", transportModel());
328 }
329
330 //! Return the temperature fits of the heat conductivity of species `i`.
331 virtual void getConductivityPolynomial(size_t i, double* coeffs) const{
332 throw NotImplementedError("Transport::getConductivityPolynomial",
333 "Not implemented for transport model '{}'.", transportModel());
334 }
335
336 //! Return the polynomial fits to the binary diffusivity of species pair (i, j)
337 virtual void getBinDiffusivityPolynomial(size_t i, size_t j, double* coeffs) const{
338 throw NotImplementedError("Transport::getBinDiffusivityPolynomial",
339 "Not implemented for transport model '{}'.", transportModel());
340 }
341
342 //! Return the polynomial fits to the collision integral of species pair (i, j)
343 virtual void getCollisionIntegralPolynomial(size_t i, size_t j,
344 double* astar_coeffs,
345 double* bstar_coeffs,
346 double* cstar_coeffs) const{
347 throw NotImplementedError("Transport::getCollisionIntegralPolynomial",
348 "Not implemented for transport model '{}'.", transportModel());
349 }
350
351 //! Modify the polynomial fits to the viscosity of species `i`
352 virtual void setViscosityPolynomial(size_t i, double* coeffs){
353 throw NotImplementedError("Transport::setViscosityPolynomial",
354 "Not implemented for transport model '{}'.", transportModel());
355 }
356
357 //! Modify the temperature fits of the heat conductivity of species `i`
358 virtual void setConductivityPolynomial(size_t i, double* coeffs){
359 throw NotImplementedError("Transport::setConductivityPolynomial",
360 "Not implemented for transport model '{}'.", transportModel());
361 }
362
363 //! Modify the polynomial fits to the binary diffusivity of species pair (i, j)
364 virtual void setBinDiffusivityPolynomial(size_t i, size_t j, double* coeffs){
365 throw NotImplementedError("Transport::setBinDiffusivityPolynomial",
366 "Not implemented for transport model '{}'.", transportModel());
367 }
368
369 //! Modify the polynomial fits to the collision integral of species pair (i, j)
370 virtual void setCollisionIntegralPolynomial(size_t i, size_t j,
371 double* astar_coeffs,
372 double* bstar_coeffs,
373 double* cstar_coeffs, bool flag){
374 throw NotImplementedError("Transport::setCollisionIntegralPolynomial",
375 "Not implemented for transport model '{}'.", transportModel());
376 }
377
378 //! Return the parameters for a phase definition which are needed to
379 //! reconstruct an identical object using the newTransport() function. This
380 //! excludes the individual species transport properties, which are handled
381 //! separately.
382 AnyMap parameters() const;
383
384 //! Get error metrics about any functional fits calculated for pure species
385 //! transport properties.
386 //!
387 //! See GasTransport::fitDiffCoeffs and GasTransport::fitProperties.
388 //!
389 //! @warning This method is an experimental part of the %Cantera API and may be
390 //! changed or removed without notice.
391 //! @since New in %Cantera 3.1.
393
394 //! @name Transport manager construction
395 //!
396 //! These methods are used during construction.
397 //! @{
398
399 //! Initialize a transport manager
400 /*!
401 * This routine sets up a transport manager. It calculates the collision
402 * integrals and populates species-dependent data structures.
403 *
404 * @param thermo Pointer to the ThermoPhase object
405 * @param mode Chemkin compatible mode or not. This alters the
406 * specification of the collision integrals. defaults to no.
407 */
408 virtual void init(ThermoPhase* thermo, int mode=0) {}
409
410 //! Boolean indicating the form of the transport properties polynomial fits.
411 //! Returns true if the Chemkin form is used.
412 virtual bool CKMode() const {
413 throw NotImplementedError("Transport::CK_Mode",
414 "Not implemented for transport model '{}'.", transportModel());
415 }
416
417 //! @}
418
419 //! Invalidate any cached values which are normally updated only when a
420 //! change in state is detected
421 //! @since New in %Cantera 3.1.
422 virtual void invalidateCache() {}
423
424protected:
425 //! pointer to the object representing the phase
427
428 //! Number of species in the phase
429 size_t m_nsp = 0;
430
431 //! Maximum errors associated with fitting pure species transport properties.
433};
434
435}
436
437#endif
A map of string keys to values whose type can vary at runtime.
Definition AnyMap.h:431
An error indicating that an unimplemented function has been called.
Base class for a phase with thermodynamic properties.
Base class for transport property managers.
Definition Transport.h:72
ThermoPhase * m_thermo
pointer to the object representing the phase
Definition Transport.h:426
virtual void init(ThermoPhase *thermo, int mode=0)
Initialize a transport manager.
Definition Transport.h:408
virtual void getBinDiffusivityPolynomial(size_t i, size_t j, double *coeffs) const
Return the polynomial fits to the binary diffusivity of species pair (i, j)
Definition Transport.h:337
virtual void setCollisionIntegralPolynomial(size_t i, size_t j, double *astar_coeffs, double *bstar_coeffs, double *cstar_coeffs, bool flag)
Modify the polynomial fits to the collision integral of species pair (i, j)
Definition Transport.h:370
void checkSpeciesIndex(size_t k) const
Check that the specified species index is in range.
Definition Transport.cpp:16
virtual double bulkViscosity()
The bulk viscosity [Pa·s].
Definition Transport.h:140
virtual double electricalConductivity()
Get the electrical conductivity [siemens/m].
Definition Transport.h:152
Transport()=default
Constructor.
virtual void getSpeciesFluxes(size_t ndim, const double *const grad_T, size_t ldx, const double *const grad_X, size_t ldf, double *const fluxes)
Get the species diffusive mass fluxes [kg/m²/s] with respect to the specified solution averaged veloc...
Definition Transport.h:199
virtual void getViscosityPolynomial(size_t i, double *coeffs) const
Return the polynomial fits to the viscosity of species i.
Definition Transport.h:325
virtual void getThermalDiffCoeffs(double *const dt)
Return a vector of thermal diffusion coefficients [kg/m/s].
Definition Transport.h:257
virtual void getMixDiffCoeffsMole(double *const d)
Returns a vector of mixture averaged diffusion coefficients [m²/s].
Definition Transport.h:313
virtual void getMolarFluxes(const double *const state1, const double *const state2, const double delta, double *const cfluxes)
Get the molar fluxes [kmol/m²/s], given the thermodynamic state at two nearby points.
Definition Transport.h:217
virtual void getConductivityPolynomial(size_t i, double *coeffs) const
Return the temperature fits of the heat conductivity of species i.
Definition Transport.h:331
virtual string transportModel() const
Identifies the model represented by this Transport object.
Definition Transport.h:93
AnyMap parameters() const
Return the parameters for a phase definition which are needed to reconstruct an identical object usin...
Definition Transport.cpp:30
virtual void getMobilities(double *const mobil_e)
Get the electrical mobilities [m²/V/s].
Definition Transport.h:173
virtual void setViscosityPolynomial(size_t i, double *coeffs)
Modify the polynomial fits to the viscosity of species i
Definition Transport.h:352
virtual void getMixDiffCoeffs(double *const d)
Return a vector of mixture averaged diffusion coefficients [m²/s].
Definition Transport.h:307
virtual void getSpeciesViscosities(double *const visc)
Get the pure species viscosities [Pa·s].
Definition Transport.h:129
virtual void getMassFluxes(const double *state1, const double *state2, double delta, double *mfluxes)
Get the mass fluxes [kg/m²/s], given the thermodynamic state at two nearby points.
Definition Transport.h:235
virtual void setConductivityPolynomial(size_t i, double *coeffs)
Modify the temperature fits of the heat conductivity of species i
Definition Transport.h:358
virtual void getBinaryDiffCoeffs(const size_t ld, double *const d)
Returns the matrix of binary diffusion coefficients [m²/s].
Definition Transport.h:272
virtual double thermalConductivity()
Get the mixture thermal conductivity [W/m/K].
Definition Transport.h:146
virtual bool CKMode() const
Boolean indicating the form of the transport properties polynomial fits.
Definition Transport.h:412
AnyMap fittingErrors() const
Get error metrics about any functional fits calculated for pure species transport properties.
Definition Transport.h:392
size_t m_nsp
Number of species in the phase.
Definition Transport.h:429
virtual void getMixDiffCoeffsMass(double *const d)
Returns a vector of mixture averaged diffusion coefficients [m²/s].
Definition Transport.h:319
ThermoPhase & thermo()
Phase object.
Definition Transport.h:103
AnyMap m_fittingErrors
Maximum errors associated with fitting pure species transport properties.
Definition Transport.h:432
void checkSpeciesArraySize(size_t kk) const
Check that an array size is at least m_nsp.
Definition Transport.cpp:23
virtual void invalidateCache()
Invalidate any cached values which are normally updated only when a change in state is detected.
Definition Transport.h:422
virtual double viscosity()
Get the dynamic viscosity [Pa·s].
Definition Transport.h:120
virtual void getMultiDiffCoeffs(const size_t ld, double *const d)
Return the multicomponent diffusion coefficients [m²/s].
Definition Transport.h:292
virtual void setBinDiffusivityPolynomial(size_t i, size_t j, double *coeffs)
Modify the polynomial fits to the binary diffusivity of species pair (i, j)
Definition Transport.h:364
virtual void getCollisionIntegralPolynomial(size_t i, size_t j, double *astar_coeffs, double *bstar_coeffs, double *cstar_coeffs) const
Return the polynomial fits to the collision integral of species pair (i, j)
Definition Transport.h:343
This file contains definitions of constants, types and terms that are used in internal routines and a...
Definitions for the classes that are thrown when Cantera experiences an error condition (also contain...
Namespace for the Cantera kernel.
Definition AnyMap.cpp:595