6cb4bd93ce
4 spaces per indentation level, no tabs, no trailing whitespace, and a single newline at end of each file.
338 lines
12 KiB
Python
338 lines
12 KiB
Python
"""
|
|
This module implements class ThermoPhase, a class representing
|
|
thermodynamic phases.
|
|
"""
|
|
from Cantera.num import zeros
|
|
from Cantera.Phase import Phase
|
|
|
|
import _cantera
|
|
import types
|
|
|
|
class ThermoPhase(Phase):
|
|
"""
|
|
A phase with an equation of state.
|
|
|
|
Class ThermoPhase may be used to represent the intensive
|
|
thermodynamic state of a phase of matter, which might be a gas,
|
|
liquid, or solid. Class ThermoPhase extends class Phase by
|
|
providing methods that require knowledge of the equation of state.
|
|
|
|
Class ThermoPhase is not usually instantiated directly. It is used
|
|
as base class for classes Solution and Interface.
|
|
|
|
@see Solution, Interface
|
|
"""
|
|
|
|
# used in the 'equilibrate' method
|
|
_equilmap = {'TP':104,'TV':100,'HP':101,'SP':102,'SV':107,'UV':105,
|
|
'PT':104,'VT':100,'PH':101,'PS':102,'VS':107,'VU':105}
|
|
|
|
|
|
def __init__(self, xml_phase=None, index=-1):
|
|
"""
|
|
xml_phase - CTML node specifying the attributes of this phase
|
|
|
|
index - optional. If positive, create only a Python wrapper for
|
|
an existing kernel object, instead of creating a new kernel object.
|
|
The value of 'index' is the integer index number to reference the
|
|
existing kernel object.
|
|
"""
|
|
|
|
self._phase_id = 0
|
|
self._owner = 0
|
|
self.idtag = ""
|
|
|
|
if index >= 0:
|
|
# create a Python wrapper for an existing kernel
|
|
# ThermoPhase instance
|
|
self._phase_id = index
|
|
|
|
elif xml_phase:
|
|
# create a new kernel instance from an XML specification
|
|
self._phase_id = _cantera.ThermoFromXML(xml_phase._xml_id)
|
|
self.idtag = xml_phase["id"]
|
|
self._owner = 1
|
|
|
|
else:
|
|
raise CanteraError('either xml_phase or index must be specified')
|
|
|
|
|
|
def __del__(self):
|
|
"""Delete the object. If it is the owner of the kernel object,
|
|
this is also deleted."""
|
|
if self._owner:
|
|
_cantera.thermo_delete(self._phase_id)
|
|
|
|
def name(self):
|
|
"""The name assigned to the phase. The default value is the name
|
|
attribute from the CTI file. But method setName can be used to
|
|
set the name to anything desired, e.g. 'gas at inlet' or 'exhaust'
|
|
"""
|
|
return self.idtag
|
|
|
|
def setName(self, name):
|
|
""" Set the name attribute. This can be any string"""
|
|
self.idtag = name
|
|
|
|
def refPressure(self):
|
|
"""Reference pressure [Pa].
|
|
All standard-state thermodynamic properties are for this pressure.
|
|
"""
|
|
return _cantera.thermo_refpressure(self._phase_id)
|
|
|
|
def minTemp(self, sp=None):
|
|
""" Minimum temperature for which thermodynamic property fits
|
|
are valid. If a species is specified (by name or number),
|
|
then the minimum temperature is for only this
|
|
species. Otherwise it is the lowest temperature for which the
|
|
properties are valid for all species. """
|
|
if not sp:
|
|
return _cantera.thermo_mintemp(self._phase_id, -1)
|
|
else:
|
|
return _cantera.thermo_mintemp(self._phase_id,
|
|
self.speciesIndex(sp))
|
|
|
|
def maxTemp(self, sp=None):
|
|
""" Maximum temperature for which thermodynamic property fits
|
|
are valid. If a species is specified (by name or number),
|
|
then the maximum temperature is for only this
|
|
species. Otherwise it is the highest temperature for which the
|
|
properties are valid for all species. """
|
|
if not sp:
|
|
return _cantera.thermo_maxtemp(self._phase_id, -1)
|
|
else:
|
|
return _cantera.thermo_maxtemp(self._phase_id,
|
|
self.speciesIndex(sp))
|
|
|
|
def enthalpy_mole(self):
|
|
""" The molar enthalpy [J/kmol]."""
|
|
return _cantera.thermo_getfp(self._phase_id,1)
|
|
|
|
def intEnergy_mole(self):
|
|
""" The molar internal energy [J/kmol]."""
|
|
return _cantera.thermo_getfp(self._phase_id,2)
|
|
|
|
def entropy_mole(self):
|
|
""" The molar entropy [J/kmol/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,3)
|
|
|
|
def gibbs_mole(self):
|
|
""" The molar Gibbs function [J/kmol]."""
|
|
return _cantera.thermo_getfp(self._phase_id,4)
|
|
|
|
def cp_mole(self):
|
|
""" The molar heat capacity at constant pressure [J/kmol/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,5)
|
|
|
|
def cv_mole(self):
|
|
""" The molar heat capacity at constant volume [J/kmol/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,6)
|
|
|
|
def pressure(self):
|
|
""" The pressure [Pa]."""
|
|
return _cantera.thermo_getfp(self._phase_id,7)
|
|
|
|
def electricPotential(self):
|
|
"""Electric potential [V]."""
|
|
return _cantera.thermo_getfp(self._phase_id,25)
|
|
|
|
def chemPotentials(self, species = []):
|
|
"""Species chemical potentials.
|
|
|
|
This method returns an array containing the species
|
|
chemical potentials [J/kmol]. The expressions used to
|
|
compute these depend on the model implemented by the
|
|
underlying kernel thermo manager."""
|
|
mu = _cantera.thermo_getarray(self._phase_id,20)
|
|
return self.selectSpecies(mu, species)
|
|
|
|
def elementPotentials(self, elements = []):
|
|
"""Element potentials of the elements.
|
|
|
|
This method returns an array containing the element potentials
|
|
[J/kmol]. The element potentials are only defined for
|
|
equilibrium states. This method first sets the composition to
|
|
a state of equilibrium holding T and P constant, then computes
|
|
the element potentials for this equilibrium state. """
|
|
|
|
lamb = _cantera.thermo_getarray(self._phase_id,21)
|
|
return self.selectElements(lamb, elements)
|
|
|
|
def enthalpies_RT(self, species = []):
|
|
"""Pure species non-dimensional reference state enthalpies.
|
|
|
|
This method returns an array containing the pure-species
|
|
standard-state enthalpies divided by RT. For gaseous species,
|
|
these values are ideal gas enthalpies."""
|
|
hrt = _cantera.thermo_getarray(self._phase_id,23)
|
|
return self.selectSpecies(hrt, species)
|
|
|
|
def entropies_R(self, species = []):
|
|
"""Pure species non-dimensional entropies.
|
|
|
|
This method returns an array containing the pure-species
|
|
standard-state entropies divided by R. For gaseous species,
|
|
these values are ideal gas entropies."""
|
|
sr = _cantera.thermo_getarray(self._phase_id,24)
|
|
return self.selectSpecies(sr, species)
|
|
|
|
def gibbs_RT(self, species = []):
|
|
"""Pure species non-dimensional Gibbs free energies.
|
|
|
|
This method returns an array containing the pure-species
|
|
standard-state Gibbs free energies divided by R.
|
|
For gaseous species, these are ideal gas values."""
|
|
grt = (_cantera.thermo_getarray(self._phase_id,23)
|
|
- _cantera.thermo_getarray(self._phase_id,24))
|
|
return self.selectSpecies(grt, species)
|
|
|
|
def cp_R(self, species = []):
|
|
"""Pure species non-dimensional heat capacities
|
|
at constant pressure.
|
|
|
|
This method returns an array containing the pure-species
|
|
standard-state heat capacities divided by R. For gaseous
|
|
species, these values are ideal gas heat capacities."""
|
|
cpr = _cantera.thermo_getarray(self._phase_id,25)
|
|
return self.selectSpecies(cpr, species)
|
|
|
|
|
|
def setPressure(self, p):
|
|
"""Set the pressure [Pa]."""
|
|
_cantera.thermo_setfp(self._phase_id,1,p,0.0)
|
|
|
|
def enthalpy_mass(self):
|
|
"""Specific enthalpy [J/kg]."""
|
|
return _cantera.thermo_getfp(self._phase_id,8)
|
|
|
|
def intEnergy_mass(self):
|
|
"""Specific internal energy [J/kg]."""
|
|
return _cantera.thermo_getfp(self._phase_id,9)
|
|
|
|
def entropy_mass(self):
|
|
"""Specific entropy [J/kg/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,10)
|
|
|
|
def gibbs_mass(self):
|
|
"""Specific Gibbs free energy [J/kg]."""
|
|
return _cantera.thermo_getfp(self._phase_id,11)
|
|
|
|
def cp_mass(self):
|
|
"""Specific heat at constant pressure [J/kg/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,12)
|
|
|
|
def cv_mass(self):
|
|
"""Specific heat at constant volume [J/kg/K]."""
|
|
return _cantera.thermo_getfp(self._phase_id,13)
|
|
|
|
def setState_TPX(self, t, p, x):
|
|
"""Set the temperature [K], pressure [Pa], and
|
|
mole fractions."""
|
|
self.setTemperature(t)
|
|
self.setMoleFractions(x)
|
|
self.setPressure(p)
|
|
|
|
def setState_TPY(self, t, p, y):
|
|
"""Set the temperature [K], pressure [Pa], and
|
|
mass fractions."""
|
|
self.setTemperature(t)
|
|
self.setMassFractions(y)
|
|
self.setPressure(p)
|
|
|
|
def setState_TP(self, t, p):
|
|
"""Set the temperature [K] and pressure [Pa]."""
|
|
self.setTemperature(t)
|
|
self.setPressure(p)
|
|
|
|
def setState_PX(self, p, x):
|
|
"""Set the pressure [Pa], and mole fractions."""
|
|
self.setMoleFractions(x)
|
|
self.setPressure(p)
|
|
|
|
def setState_PY(self, p, y):
|
|
"""Set the pressure [Pa], and mass fractions."""
|
|
self.setMassFractions(y)
|
|
self.setPressure(p)
|
|
|
|
def setState_HP(self, h, p):
|
|
"""Set the state by specifying the specific enthalpy and
|
|
the pressure."""
|
|
_cantera.thermo_setfp(self._phase_id, 2, h, p)
|
|
|
|
def setState_UV(self, u, v):
|
|
"""Set the state by specifying the specific internal
|
|
energy and the specific volume."""
|
|
_cantera.thermo_setfp(self._phase_id, 3, u, v)
|
|
|
|
def setState_SV(self, s, v):
|
|
"""Set the state by specifying the specific entropy
|
|
and the specific volume."""
|
|
_cantera.thermo_setfp(self._phase_id, 4, s, v)
|
|
|
|
def setState_SP(self, s, p):
|
|
"""Set the state by specifying the specific entropy
|
|
energy and the pressure."""
|
|
_cantera.thermo_setfp(self._phase_id, 5, s, p)
|
|
|
|
def setElectricPotential(self, v):
|
|
"""Set the electric potential."""
|
|
_cantera.thermo_setfp(self._phase_id, 6, v, 0);
|
|
|
|
def equilibrate(self, XY, solver = -1, rtol = 1.0e-9,
|
|
maxsteps = 1000, maxiter = 100, loglevel = 0):
|
|
""" Set to a state of chemical equilibrium holding property pair
|
|
'XY' constant.
|
|
|
|
XY --- A two-letter string, which must be one of the set
|
|
['TP','TV','HP','SP','SV','UV','PT','VT','PH','PS','VS','VU'].
|
|
If H, U, S, or V is specified, the value must be the specific
|
|
value (per unit mass)
|
|
|
|
solver --- Specifies the equilibrium solver to use. If solver =
|
|
0, a fast solver using the element potential method will be
|
|
used. If solver > 0, a slower but more robust Gibbs
|
|
minimization solver will be used. If solver < 0 or
|
|
unspecified, the fast solver will be tried first, then if it
|
|
fails the other will be tried.
|
|
|
|
rtol -- the relative error tolerance.
|
|
|
|
maxsteps -- maximum number of steps in composition to take to
|
|
find a converged solution.
|
|
|
|
maxiter -- for the Gibbs minimization solver only, this
|
|
specifies the number of 'outer' iterations on T or P when some
|
|
property pair other than TP is specified.
|
|
|
|
loglevel -- set to a value > 0 to write diagnostic output to a
|
|
file in HTML format. Larger values generate more detailed
|
|
information. The file will be named 'equilibrate_log.html.'
|
|
Subsequent files will be named 'equillibrate_log1.html', etc.,
|
|
so that log files are not overwritten.
|
|
|
|
"""
|
|
_cantera.thermo_equil(self._phase_id, XY, solver,
|
|
rtol, maxsteps, maxiter, loglevel)
|
|
|
|
def saveState(self):
|
|
"""Return an array with state information that can later be
|
|
used to restore the state."""
|
|
state = zeros(self.nSpecies()+2,'d')
|
|
state[0] = self.temperature()
|
|
state[1] = self.density()
|
|
state[2:] = self.massFractions()
|
|
return state
|
|
|
|
def restoreState(self, s):
|
|
"""Restore the state to that stored in array s."""
|
|
self.setState_TRY(s[0], s[1], s[2:])
|
|
|
|
def thermophase(self):
|
|
"""Return the integer index that is used to
|
|
reference the kernel object. For internal use."""
|
|
return self._phase_id
|
|
|
|
def thermo_hndl(self):
|
|
"""Return the integer index that is used to
|
|
reference the kernel object. For internal use."""
|
|
return self._phase_id
|