Help on Solution in module cantera.composite object:
class Solution(cantera._cantera.ThermoPhase, cantera._cantera.Kinetics, cantera._cantera.Transport)
| A class for chemically-reacting solutions. Instances can be created to
| represent any type of solution -- a mixture of gases, a liquid solution, or
| a solid solution, for example.
|
| Class `Solution` derives from classes `ThermoPhase`, `Kinetics`, and
| `Transport`. It defines no methods of its own, and is provided so that a
| single object can be used to compute thermodynamic, kinetic, and transport
| properties of a solution.
|
| To skip initialization of the Transport object, pass the keyword argument
| ``transport_model=None`` to the `Solution` constructor.
|
| The most common way to instantiate `Solution` objects is by using a phase
| definition, species and reactions defined in an input file::
|
| gas = ct.Solution('gri30.cti')
|
| If an input file defines multiple phases, the phase *name* (in CTI) or *id*
| (in XML) can be used to specify the desired phase::
|
| gas = ct.Solution('diamond.cti', 'gas')
| diamond = ct.Solution('diamond.cti', 'diamond')
|
| `Solution` objects can also be constructed using `Species` and `Reaction`
| objects which can themselves either be imported from input files or defined
| directly in Python::
|
| spec = ct.Species.listFromFile('gri30.cti')
| rxns = ct.Reaction.listFromFile('gri30.cti')
| gas = ct.Solution(thermo='IdealGas', kinetics='GasKinetics',
| species=spec, reactions=rxns)
|
| where the ``thermo`` and ``kinetics`` keyword arguments are strings
| specifying the thermodynamic and kinetics model, respectively, and
| ``species`` and ``reactions`` keyword arguments are lists of `Species` and
| `Reaction` objects, respectively.
|
| For non-trivial uses cases of this functionality, see the examples
| :ref:`py-example-extract_submechanism.py` and
| :ref:`py-example-mechanism_reduction.py`.
|
| In addition, `Solution` objects can be constructed by passing the text of
| the CTI or XML phase definition in directly, using the ``source`` keyword
| argument::
|
| cti_def = '''
| ideal_gas(name='gas', elements='O H Ar',
| species='gri30: all',
| reactions='gri30: all',
| options=['skip_undeclared_elements', 'skip_undeclared_species', 'skip_undeclared_third_bodies'],
| initial_state=state(temperature=300, pressure=101325))'''
| gas = ct.Solution(source=cti_def)
|
| Method resolution order:
| Solution
| cantera._cantera.ThermoPhase
| cantera._cantera.Kinetics
| cantera._cantera.Transport
| cantera._cantera._SolutionBase
| builtins.object
|
| Methods inherited from cantera._cantera.ThermoPhase:
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| add_species(...)
| ThermoPhase.add_species(self, Species species)
|
| Add a new species to this phase. Missing elements will be added
| automatically.
|
| atomic_weight(...)
| ThermoPhase.atomic_weight(self, m)
| Atomic weight [kg/kmol] of element *m*
|
| element_index(...)
| ThermoPhase.element_index(self, element) -> int
|
| The index of element *element*, which may be specified as a string or
| an integer. In the latter case, the index is checked for validity and
| returned. If no such element is present, an exception is thrown.
|
| element_name(...)
| ThermoPhase.element_name(self, m)
| Name of the element with index *m*.
|
| element_potentials(...)
| ThermoPhase.element_potentials(self)
|
| Get the array of element potentials. The element potentials are only
| defined for equilibrium states. This method first sets the composition
| to a state of equilibrium at constant T and P, then computes the
| element potentials for this equilibrium state.
|
| elemental_mass_fraction(...)
| ThermoPhase.elemental_mass_fraction(self, m)
|
| Get the elemental mass fraction :math:`Z_{\mathrm{mass},m}` of element
| :math:`m` as defined by:
|
| .. math:: Z_{\mathrm{mass},m} = \sum_k \frac{a_{m,k} M_m}{M_k} Y_k
|
| with :math:`a_{m,k}` being the number of atoms of element :math:`m` in
| species :math:`k`, :math:`M_m` the atomic weight of element :math:`m`,
| :math:`M_k` the molecular weight of species :math:`k`, and :math:`Y_k`
| the mass fraction of species :math:`k`.
|
| :param m:
| Base element, may be specified by name or by index.
|
| >>> phase.elemental_mass_fraction('H')
| 1.0
|
| elemental_mole_fraction(...)
| ThermoPhase.elemental_mole_fraction(self, m)
|
| Get the elemental mole fraction :math:`Z_{\mathrm{mole},m}` of element
| :math:`m` (the number of atoms of element m divided by the total number
| of atoms) as defined by:
|
| .. math:: Z_{\mathrm{mole},m} = \frac{\sum_k a_{m,k} X_k}
| {\sum_k \sum_j a_{j,k} X_k}
|
| with :math:`a_{m,k}` being the number of atoms of element :math:`m` in
| species :math:`k`, :math:`\sum_j` being a sum over all elements, and
| :math:`X_k` being the mole fraction of species :math:`k`.
|
| :param m:
| Base element, may be specified by name or by index.
|
| >>> phase.elemental_mole_fraction('H')
| 1.0
|
| equilibrate(...)
| ThermoPhase.equilibrate(self, XY, solver='auto', double rtol=1e-9, int maxsteps=1000, int maxiter=100, int estimate_equil=0, int loglevel=0)
|
| Set to a state of chemical equilibrium holding property pair
| *XY* constant.
|
| :param XY:
| A two-letter string, which must be one of the set::
|
| ['TP','TV','HP','SP','SV','UV']
|
| :param solver:
| Specifies the equilibrium solver to use. May be one of the following:
|
| * ''element_potential'' - a fast solver using the element potential
| method
| * 'gibbs' - a slower but more robust Gibbs minimization solver
| * 'vcs' - the VCS non-ideal equilibrium solver
| * "auto" - The element potential solver will be tried first, then
| if it fails the Gibbs solver will be tried.
| :param rtol:
| the relative error tolerance.
| :param maxsteps:
| maximum number of steps in composition to take to find a converged
| solution.
| :param maxiter:
| For the Gibbs minimization solver, this specifies the number of
| 'outer' iterations on T or P when some property pair other
| than TP is specified.
| :param estimate_equil:
| Integer indicating whether the solver should estimate its own
| initial condition. If 0, the initial mole fraction vector in the
| ThermoPhase object is used as the initial condition. If 1, the
| initial mole fraction vector is used if the element abundances are
| satisfied. If -1, the initial mole fraction vector is thrown out,
| and an estimate is formulated.
| :param loglevel:
| Set to a value > 0 to write diagnostic output.
|
| get_equivalence_ratio(...)
| ThermoPhase.get_equivalence_ratio(self, oxidizers=[], ignore=[])
|
| Get the composition of a fuel/oxidizer mixture. This gives the
| equivalence ratio of an unburned mixture. This is not a quantity that is
| conserved after oxidation. Considers the oxidation of C to CO2, H to H2O
| and S to SO2. Other elements are assumed not to participate in oxidation
| (i.e. N ends up as N2).
| :param oxidizers:
| List of oxidizer species names as strings. Default: with
| ``oxidizers=[]``, every species that contains O but does not contain
| H, C, or S is considered to be an oxidizer.
| :param ignore:
| List of species names as strings to ignore.
| >>> gas.set_equivalence_ratio(0.5, 'CH3:0.5, CH3OH:.5, N2:0.125', 'O2:0.21, N2:0.79, NO:0.01')
| >>> gas.get_equivalence_ratio()
| 0.50000000000000011
| >>> gas.get_equivalence_ratio(['O2']) # Only consider O2 as the oxidizer instead of O2 and NO
| 0.48809523809523814
| >>> gas.X = 'CH4:1, O2:2, NO:0.1'
| >>> gas.get_equivalence_ratio(ignore=['NO'])
| 1.0
|
| mass_fraction_dict(...)
| ThermoPhase.mass_fraction_dict(self, double threshold=0.0)
|
| modify_species(...)
| ThermoPhase.modify_species(self, k, Species species)
|
| mole_fraction_dict(...)
| ThermoPhase.mole_fraction_dict(self, double threshold=0.0)
|
| n_atoms(...)
| ThermoPhase.n_atoms(self, species, element)
|
| Number of atoms of element *element* in species *species*. The element
| and species may be specified by name or by index.
|
| >>> phase.n_atoms('CH4','H')
| 4
|
| report(...)
| ThermoPhase.report(self, show_thermo=True, float threshold=1e-14)
|
| Generate a report describing the thermodynamic state of this phase. To
| print the report to the terminal, simply call the phase object. The
| following two statements are equivalent::
|
| >>> phase()
| >>> print(phase.report())
|
| set_equivalence_ratio(...)
| ThermoPhase.set_equivalence_ratio(self, phi, fuel, oxidizer)
|
| Set the composition to a mixture of *fuel* and *oxidizer* at the
| specified equivalence ratio *phi*, holding temperature and pressure
| constant. Considers the oxidation of C and H to CO2 and H2O. Other
| elements are assumed not to participate in oxidation (i.e. N ends up as
| N2)::
|
| >>> gas.set_equivalence_ratio(0.5, 'CH4', 'O2:1.0, N2:3.76')
| >>> gas.mole_fraction_dict()
| {'CH4': 0.049900199, 'N2': 0.750499001, 'O2': 0.199600798}
|
| >>> gas.set_equivalence_ratio(1.2, {'NH3;:0.8, 'CO':0.2}, 'O2:1.0')
| >>> gas.mole_fraction_dict()
| {'CO': 0.1263157894, 'NH3': 0.505263157, 'O2': 0.36842105}
|
| :param phi: Equivalence ratio
| :param fuel:
| Fuel species name or molar composition as string, array, or dict.
| :param oxidizer:
| Oxidizer species name or molar composition as a string, array, or
| dict.
|
| set_unnormalized_mass_fractions(...)
| ThermoPhase.set_unnormalized_mass_fractions(self, Y)
|
| Set the mass fractions without normalizing to force sum(Y) == 1.0.
| Useful primarily when calculating derivatives with respect to Y[k] by
| finite difference.
|
| set_unnormalized_mole_fractions(...)
| ThermoPhase.set_unnormalized_mole_fractions(self, X)
|
| Set the mole fractions without normalizing to force sum(X) == 1.0.
| Useful primarily when calculating derivatives with respect to X[k]
| by finite difference.
|
| species(...)
| ThermoPhase.species(self, k=None)
|
| Return the `Species` object for species *k*, where *k* is either the
| species index or the species name. If *k* is not specified, a list of
| all species objects is returned.
|
| species_index(...)
| ThermoPhase.species_index(self, species) -> int
|
| The index of species *species*, which may be specified as a string or
| an integer. In the latter case, the index is checked for validity and
| returned. If no such species is present, an exception is thrown.
|
| species_name(...)
| ThermoPhase.species_name(self, k)
| Name of the species with index *k*.
|
| ----------------------------------------------------------------------
| Static methods inherited from cantera._cantera.ThermoPhase:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cantera._cantera.ThermoPhase:
|
| DP
| Get/Set density [kg/m^3] and pressure [Pa].
|
| DPX
| Get/Set density [kg/m^3], pressure [Pa], and mole fractions.
|
| DPY
| Get/Set density [kg/m^3], pressure [Pa], and mass fractions.
|
| HP
| Get/Set enthalpy [J/kg or J/kmol] and pressure [Pa].
|
| HPX
| Get/Set enthalpy [J/kg or J/kmol], pressure [Pa] and mole fractions.
|
| HPY
| Get/Set enthalpy [J/kg or J/kmol], pressure [Pa] and mass fractions.
|
| ID
| The ID of the phase. The default is taken from the CTI/XML input file.
|
| P
| Pressure [Pa].
|
| P_sat
| Saturation pressure [Pa] at the current temperature.
|
| SP
| Get/Set entropy [J/kg/K or J/kmol/K] and pressure [Pa].
|
| SPX
| Get/Set entropy [J/kg/K or J/kmol/K], pressure [Pa], and mole fractions.
|
| SPY
| Get/Set entropy [J/kg/K or J/kmol/K], pressure [Pa], and mass fractions.
|
| SV
| Get/Set entropy [J/kg/K or J/kmol/K] and specific volume [m^3/kg or
| m^3/kmol].
|
| SVX
| Get/Set entropy [J/kg/K or J/kmol/K], specific volume [m^3/kg or
| m^3/kmol], and mole fractions.
|
| SVY
| Get/Set entropy [J/kg/K or J/kmol/K], specific volume [m^3/kg or
| m^3/kmol], and mass fractions.
|
| T
| Temperature [K].
|
| TD
| Get/Set temperature [K] and density [kg/m^3 or kmol/m^3].
|
| TDX
| Get/Set temperature [K], density [kg/m^3 or kmol/m^3], and mole
| fractions.
|
| TDY
| Get/Set temperature [K] and density [kg/m^3 or kmol/m^3], and mass
| fractions.
|
| TP
| Get/Set temperature [K] and pressure [Pa].
|
| TPX
| Get/Set temperature [K], pressure [Pa], and mole fractions.
|
| TPY
| Get/Set temperature [K], pressure [Pa], and mass fractions.
|
| T_sat
| Saturation temperature [K] at the current pressure.
|
| UV
| Get/Set internal energy [J/kg or J/kmol] and specific volume
| [m^3/kg or m^3/kmol].
|
| UVX
| Get/Set internal energy [J/kg or J/kmol], specific volume
| [m^3/kg or m^3/kmol], and mole fractions.
|
| UVY
| Get/Set internal energy [J/kg or J/kmol], specific volume
| [m^3/kg or m^3/kmol], and mass fractions.
|
| X
| Get/Set the species mole fractions. Can be set as an array, as a dictionary,
| or as a string. Always returns an array::
|
| >>> phase.X = [0.1, 0, 0, 0.4, 0, 0, 0, 0, 0.5]
| >>> phase.X = {'H2':0.1, 'O2':0.4, 'AR':0.5}
| >>> phase.X = 'H2:0.1, O2:0.4, AR:0.5'
| >>> phase.X
| array([0.1, 0, 0, 0.4, 0, 0, 0, 0, 0.5])
|
| Y
| Get/Set the species mass fractions. Can be set as an array, as a dictionary,
| or as a string. Always returns an array::
|
| >>> phase.Y = [0.1, 0, 0, 0.4, 0, 0, 0, 0, 0.5]
| >>> phase.Y = {'H2':0.1, 'O2':0.4, 'AR':0.5}
| >>> phase.Y = 'H2:0.1, O2:0.4, AR:0.5'
| >>> phase.Y
| array([0.1, 0, 0, 0.4, 0, 0, 0, 0, 0.5])
|
| atomic_weights
| Array of atomic weight [kg/kmol] for each element in the mixture.
|
| basis
| Determines whether intensive thermodynamic properties are treated on a
| `mass` (per kg) or `molar` (per kmol) basis. This affects the values
| returned by the properties `h`, `u`, `s`, `g`, `v`, `density`, `cv`,
| and `cp`, as well as the values used with the state-setting properties
| such as `HPX` and `UV`.
|
| chemical_potentials
| Array of species chemical potentials [J/kmol].
|
| concentrations
| Get/Set the species concentrations [kmol/m^3].
|
| cp
| Heat capacity at constant pressure [J/kg/K or J/kmol/K] depending
| on `basis`.
|
| cp_mass
| Specific heat capacity at constant pressure [J/kg/K].
|
| cp_mole
| Molar heat capacity at constant pressure [J/kmol/K].
|
| critical_density
| Critical density [kg/m^3 or kmol/m^3] depending on `basis`.
|
| critical_pressure
| Critical pressure [Pa].
|
| critical_temperature
| Critical temperature [K].
|
| cv
| Heat capacity at constant volume [J/kg/K or J/kmol/K] depending on
| `basis`.
|
| cv_mass
| Specific heat capacity at constant volume [J/kg/K].
|
| cv_mole
| Molar heat capacity at constant volume [J/kmol/K].
|
| density
| Density [kg/m^3 or kmol/m^3] depending on `basis`.
|
| density_mass
| (Mass) density [kg/m^3].
|
| density_mole
| Molar density [kmol/m^3].
|
| electric_potential
| Get/Set the electric potential [V] for this phase.
|
| electrochemical_potentials
| Array of species electrochemical potentials [J/kmol].
|
| element_names
| A list of all the element names.
|
| enthalpy_mass
| Specific enthalpy [J/kg].
|
| enthalpy_mole
| Molar enthalpy [J/kmol].
|
| entropy_mass
| Specific entropy [J/kg].
|
| entropy_mole
| Molar entropy [J/kmol/K].
|
| g
| Gibbs free energy [J/kg or J/kmol] depending on `basis`.
|
| gibbs_mass
| Specific Gibbs free energy [J/kg].
|
| gibbs_mole
| Molar Gibbs free energy [J/kmol].
|
| h
| Enthalpy [J/kg or J/kmol] depending on `basis`.
|
| int_energy_mass
| Specific internal energy [J/kg].
|
| int_energy_mole
| Molar internal energy [J/kmol].
|
| isothermal_compressibility
| Isothermal compressibility [1/Pa].
|
| max_temp
| Maximum temperature for which the thermodynamic data for the phase are
| valid.
|
| mean_molecular_weight
| The mean molecular weight (molar mass) [kg/kmol].
|
| min_temp
| Minimum temperature for which the thermodynamic data for the phase are
| valid.
|
| molecular_weights
| Array of species molecular weights (molar masses) [kg/kmol].
|
| n_elements
| Number of elements.
|
| n_selected_species
| Number of species selected for output (by slicing of Solution object)
|
| n_species
| Number of species.
|
| name
| The name assigned to this phase. The default is taken from the CTI/XML
| input file.
|
| partial_molar_cp
| Array of species partial molar specific heat capacities at constant
| pressure [J/kmol/K].
|
| partial_molar_enthalpies
| Array of species partial molar enthalpies [J/kmol].
|
| partial_molar_entropies
| Array of species partial molar entropies [J/kmol/K].
|
| partial_molar_int_energies
| Array of species partial molar internal energies [J/kmol].
|
| partial_molar_volumes
| Array of species partial molar volumes [m^3/kmol].
|
| reference_pressure
| Reference state pressure [Pa].
|
| s
| Entropy [J/kg/K or J/kmol/K] depending on `basis`.
|
| species_names
| A list of all the species names.
|
| standard_cp_R
| Array of nondimensional species standard-state specific heat capacities
| at constant pressure at the current temperature and pressure.
|
| standard_enthalpies_RT
| Array of nondimensional species standard-state enthalpies at the
| current temperature and pressure.
|
| standard_entropies_R
| Array of nondimensional species standard-state entropies at the
| current temperature and pressure.
|
| standard_gibbs_RT
| Array of nondimensional species standard-state Gibbs free energies at
| the current temperature and pressure.
|
| standard_int_energies_RT
| Array of nondimensional species standard-state internal energies at the
| current temperature and pressure.
|
| state
| Get/Set the full thermodynamic state as a single array, arranged as
| [temperature, density, mass fractions] for most phases. Useful mainly
| in cases where it is desired to store many states in a multidimensional
| array.
|
| thermal_expansion_coeff
| Thermal expansion coefficient [1/K].
|
| u
| Internal energy in [J/kg or J/kmol].
|
| v
| Specific volume [m^3/kg or m^3/kmol] depending on `basis`.
|
| volume_mass
| Specific volume [m^3/kg].
|
| volume_mole
| Molar volume [m^3/kmol].
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cantera._cantera.ThermoPhase:
|
| __pyx_vtable__ = <capsule object NULL>
|
| ----------------------------------------------------------------------
| Methods inherited from cantera._cantera.Kinetics:
|
| add_reaction(...)
| Kinetics.add_reaction(self, Reaction rxn)
| Add a new reaction to this phase.
|
| is_reversible(...)
| Kinetics.is_reversible(self, int i_reaction)
| True if reaction `i_reaction` is reversible.
|
| kinetics_species_index(...)
| Kinetics.kinetics_species_index(self, species, int phase=0)
|
| The index of species *species* of phase *phase* within arrays returned
| by methods of class `Kinetics`. If *species* is a string, the *phase*
| argument is unused.
|
| modify_reaction(...)
| Kinetics.modify_reaction(self, int irxn, Reaction rxn)
|
| Modify the `Reaction` with index ``irxn`` to have the same rate
| parameters as ``rxn``. ``rxn`` must have the same reactants and products
| and be of the same type (i.e. `ElementaryReaction`, `FalloffReaction`,
| `PlogReaction`, etc.) as the existing reaction. This method does not
| modify the third-body efficiencies, reaction orders, or reversibility of
| the reaction.
|
| multiplier(...)
| Kinetics.multiplier(self, int i_reaction)
|
| A scaling factor applied to the rate coefficient for reaction
| *i_reaction*. Can be used to carry out sensitivity analysis or to
| selectively disable a particular reaction. See `set_multiplier`.
|
| product_stoich_coeff(...)
| Kinetics.product_stoich_coeff(self, k_spec, int i_reaction)
|
| The stoichiometric coefficient of species *k_spec* as a product in
| reaction *i_reaction*.
|
| product_stoich_coeffs(...)
| Kinetics.product_stoich_coeffs(self)
|
| The array of product stoichiometric coefficients. Element *[k,i]* of
| this array is the product stoichiometric coefficient of species *k* in
| reaction *i*.
|
| products(...)
| Kinetics.products(self, int i_reaction)
| The products portion of the reaction equation
|
| reactant_stoich_coeff(...)
| Kinetics.reactant_stoich_coeff(self, k_spec, int i_reaction)
|
| The stoichiometric coefficient of species *k_spec* as a reactant in
| reaction *i_reaction*.
|
| reactant_stoich_coeffs(...)
| Kinetics.reactant_stoich_coeffs(self)
|
| The array of reactant stoichiometric coefficients. Element *[k,i]* of
| this array is the reactant stoichiometric coefficient of species *k* in
| reaction *i*.
|
| reactants(...)
| Kinetics.reactants(self, int i_reaction)
| The reactants portion of the reaction equation
|
| reaction(...)
| Kinetics.reaction(self, int i_reaction)
|
| Return a `Reaction` object representing the reaction with index
| ``i_reaction``.
|
| reaction_equation(...)
| Kinetics.reaction_equation(self, int i_reaction)
| The equation for the specified reaction. See also `reaction_equations`.
|
| reaction_equations(...)
| Kinetics.reaction_equations(self, indices=None)
|
| Returns a list containing the reaction equation for all reactions in the
| mechanism (if *indices* is unspecified) or the equations for each
| reaction in the sequence *indices*. For example::
|
| >>> gas.reaction_equations()
| ['2 O + M <=> O2 + M', 'O + H + M <=> OH + M', 'O + H2 <=> H + OH', ...]
| >>> gas.reaction_equations([2,3])
| ['O + H + M <=> OH + M', 'O + H2 <=> H + OH']
|
| See also `reaction_equation`.
|
| reaction_type(...)
| Kinetics.reaction_type(self, int i_reaction)
| Type of reaction *i_reaction*.
|
| reactions(...)
| Kinetics.reactions(self)
|
| Return a list of all `Reaction` objects
|
| reset_custom(...)
| Kinetics.reset_custom(self)
|
| Function calling the dlclose in CustomKinetics
| in order to close the dynamic library (handle)
|
| set_multiplier(...)
| Kinetics.set_multiplier(self, double value, int i_reaction=-1)
|
| Set the multiplier for for reaction *i_reaction* to *value*.
| If *i_reaction* is not specified, then the multiplier for all reactions
| is set to *value*. See `multiplier`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cantera._cantera.Kinetics:
|
| creation_rates
| Creation rates for each species. [kmol/m^3/s] for bulk phases or
| [kmol/m^2/s] for surface phases.
|
| delta_enthalpy
| Change in enthalpy for each reaction [J/kmol].
|
| delta_entropy
| Change in entropy for each reaction [J/kmol/K].
|
| delta_gibbs
| Change in Gibbs free energy for each reaction [J/kmol].
|
| delta_standard_enthalpy
| Change in standard-state enthalpy (independent of composition) for
| each reaction [J/kmol].
|
| delta_standard_entropy
| Change in standard-state entropy (independent of composition) for
| each reaction [J/kmol/K].
|
| delta_standard_gibbs
| Change in standard-state Gibbs free energy (independent of composition)
| for each reaction [J/kmol].
|
| destruction_rates
| Destruction rates for each species. [kmol/m^3/s] for bulk phases or
| [kmol/m^2/s] for surface phases.
|
| equilibrium_constants
| Equilibrium constants in concentration units for all reactions.
|
| forward_rate_constants
| Forward rate constants for all reactions. Units are a combination of
| kmol, m^3 and s, that depend on the rate expression for the reaction.
|
| forward_rates_of_progress
| Forward rates of progress for the reactions. [kmol/m^3/s] for bulk
| phases or [kmol/m^2/s] for surface phases.
|
| n_phases
| Number of phases in the reaction mechanism.
|
| n_reactions
| Number of reactions in the reaction mechanism.
|
| n_total_species
| Total number of species in all phases participating in the kinetics
| mechanism.
|
| net_production_rates
| Net production rates for each species. [kmol/m^3/s] for bulk phases or
| [kmol/m^2/s] for surface phases.
|
| net_rates_of_progress
| Net rates of progress for the reactions. [kmol/m^3/s] for bulk phases
| or [kmol/m^2/s] for surface phases.
|
| reaction_phase_index
| The index of the phase where the reactions occur.
|
| reverse_rate_constants
| Reverse rate constants for all reactions. Units are a combination of
| kmol, m^3 and s, that depend on the rate expression for the reaction.
|
| reverse_rates_of_progress
| Reverse rates of progress for the reactions. [kmol/m^3/s] for bulk
| phases or [kmol/m^2/s] for surface phases.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cantera._cantera.Transport:
|
| binary_diff_coeffs
| Binary diffusion coefficients [m^2/s].
|
| electrical_conductivity
| Electrical conductivity. [S/m].
|
| mix_diff_coeffs
| Mixture-averaged diffusion coefficients [m^2/s] relating the
| mass-averaged diffusive fluxes (with respect to the mass averaged
| velocity) to gradients in the species mole fractions.
|
| mix_diff_coeffs_mass
| Mixture-averaged diffusion coefficients [m^2/s] relating the
| diffusive mass fluxes to gradients in the species mass fractions.
|
| mix_diff_coeffs_mole
| Mixture-averaged diffusion coefficients [m^2/s] relating the
| molar diffusive fluxes to gradients in the species mole fractions.
|
| multi_diff_coeffs
| Multicomponent diffusion coefficients [m^2/s].
|
| species_viscosities
| Pure species viscosities [Pa-s]
|
| thermal_conductivity
| Thermal conductivity. [W/m/K].
|
| thermal_diff_coeffs
| Return a one-dimensional array of the species thermal diffusion
| coefficients [kg/m/s].
|
| transport_model
| Get/Set the transport model associated with this transport model.
|
| Setting a new transport model deletes the underlying C++ Transport
| object and replaces it with a new one implementing the specified model.
|
| viscosity
| Viscosity [Pa-s].
|
| ----------------------------------------------------------------------
| Methods inherited from cantera._cantera._SolutionBase:
|
| __copy__(...)
| _SolutionBase.__copy__(self)
|
| __getitem__(self, key, /)
| Return self[key].
|
| __reduce__(...)
| _SolutionBase.__reduce__(self)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cantera._cantera._SolutionBase:
|
| selected_species