High-Level Interface¶
PropsSI function¶
For many users, all that is needed is a simple call to the PropsSI
function for pure fluids, pseudo-pure fluids and mixtures. For humid air properties, see Humid air properties. An example using PropsSI
:
# Import the PropsSI function
In [1]: from CoolProp.CoolProp import PropsSI
# Saturation temperature of Water at 1 atm in K
In [2]: PropsSI('T','P',101325,'Q',0,'Water')
Out[2]: 373.1242958476844
In this example, the first parameter, \(T\), is the output property that will be returned from PropsSI
. The second and fourth parameters are the specified input pair of properties that determine the state point where the output property will be calculated. The output property and input pair properties are text strings and must be quoted. The third and fifth parameters are the values of the input pair properties and will determine the state point. The sixth and last parameter is the fluid for which the output property will be calculated; also a quoted string.
More information:
All the wrappers wrap this function in exactly the same way.
For pure and pseudo-pure fluids, two state variables are required to fix the state. The equations of state are based on \(T\) and \(\rho\) as state variables, so \(T, \rho\) will always be the fastest inputs. \(P,T\) will be a bit slower (3-10 times), followed by input pairs where neither \(T\) nor \(\rho\) are specified, like \(P,H\); these will be much slower. If speed is an issue, you can look into table-based interpolation methods using TTSE or bicubic interpolation; or if you are only interested in Water properties, you can look into using the IF97 (industrial formulation) backend.
Vapor, Liquid, and Saturation States¶
If the input pair (say, \(P,T\)) defines a state point that lies in the vapor region, then the vapor property at that state point will be returned. Likewise, if the state point lies in the liquid region, then the liquid state property at that state point will be returned. If the state point defined by the input pair lies within 1E-4 % of the saturation pressure, then CoolProp may return an error, because both liquid and vapor are defined along the saturation curve.
To retrieve either the vapor or liquid properties along the saturation curve, provide an input pair that includes either the saturation temperature, \(T\), or saturation pressure, \(p\), along with the vapor quality, \(Q\). Use a value of \(Q=1\) for the saturated vapor property or \(Q=0\) for the saturated liquid property. For example, at a saturation pressure of 1 atm, the liquid and vapor enthalpies can be returned as follows.
# Import the PropsSI function
In [3]: from CoolProp.CoolProp import PropsSI
# Saturated vapor enthalpy of Water at 1 atm in J/kg
In [4]: H_V = PropsSI('H','P',101325,'Q',1,'Water'); print(H_V)
2675529.3255007486
# Saturated liquid enthalpy of Water at 1 atm in J/kg
In [5]: H_L = PropsSI('H','P',101325,'Q',0,'Water'); print(H_L)
419057.7330940691
# Latent heat of vaporization of Water at 1 atm in J/kg
In [6]: H_V - H_L
Out[6]: 2256471.5924066794
Note
The latent heat of vaporization can be calculated using the difference between the vapor and liquid enthalpies at the same point on the saturation curve.
Imposing the Phase (Optional)¶
Each call to PropsSI()
requires the phase to be determined based on the provided input pair, and may require a non-trivial flash calculation to determine if the state point is in the single-phase or two-phase region and to generate a sensible initial guess for the solver. For computational efficiency, PropsSI()
allows the phase to be manually imposed through the input key parameters. If unspecified, PropsSI will attempt to determine the phase automatically.
Depending on the input pair, there may or may not be a speed benefit to imposing a phase. However, some state points may not be able to find a suitable initial guess for the solver and being able to impose the phase manually may offer a solution if the solver is failing. Additionally, with an input pair in the two-phase region, it can be useful to impose a liquid or gas phase to instruct PropsSI()
to return the saturated liquid or saturated gas properties.
To specify the phase to be used, add the “|” delimiter to one (and only one) of the input key strings followed by one of the phase strings in the table below:
Phase String |
Phase Region |
---|---|
“liquid” |
p < pcrit & T < Tcrit ; above saturation |
“gas” |
p < pcrit & T < Tcrit ; below saturation |
“twophase” |
p < pcrit & T < Tcrit ; mixed liquid/gas |
“supercritical_liquid” |
p > pcrit & T < Tcrit |
“supercritical_gas” |
p < pcrit & T > Tcrit |
“supercritical” |
p > pcrit & T > Tcrit |
“not_imposed” |
(Default) CoolProp to determine phase |
For example:
# Get the density of Water at T = 461.1 K and P = 5.0e6 Pa, imposing the liquid phase
In [7]: PropsSI('D','T|liquid',461.1,'P',5e6,'Water')
Out[7]: 881.000853334732
# Get the density of Water at T = 597.9 K and P = 5.0e6 Pa, imposing the gas phase
In [8]: PropsSI('D','T',597.9,'P|gas',5e6,'Water')
Out[8]: 20.508496070580005
On each call to PropsSI()
, the imposed phase is reset to “not_imposed” as long as no imposed phase strings are used. A phase string must be appended to an Input key string on each and every call to PropsSI()
to impose the phase. PropsSI()
will return an error for any of the following syntax conditions:
If anything other than the pipe, “|”, symbol is used as the delimiter
If the phase string is not one of the valid phase strings in the table above
If the phase string is applied to more than one of the Input key parameters
In addition, for consistency with the low-level interface, the valid phase strings in the table above may be prefixed with either “phase_” or “iphase_” and still be recognized as a valid phase string.
Warning
When specifying an imposed phase, it is absolutely critical that the input pair actually lie within the imposed phase region. If an incorrect phase is imposed for the given input pair, PropsSI()
may throw unexpected errors or incorrect results may possibly be returned from the property functions. If the state point phase is not absolutely known, it is best to let CoolProp determine the phase.
Fluid information¶
You can obtain string-encoded information about the fluid from the get_fluid_param_string
function with something like:
In [9]: import CoolProp.CoolProp as CP
In [10]: for k in ['formula','CAS','aliases','ASHRAE34','REFPROP_name','pure','INCHI','INCHI_Key','CHEMSPIDER_ID']:
....: item = k + ' --> ' + CP.get_fluid_param_string("R125", k)
....: print(item)
....:
formula --> C_{2}F_{5}H_{1}
CAS --> 354-33-6
aliases -->
ASHRAE34 --> UNKNOWN
REFPROP_name --> R125
pure --> true
INCHI --> InChI=1S/C2HF5/c3-1(4)2(5,6)7/h1H
INCHI_Key --> GTLACDSXYULKMZ-UHFFFAOYSA-N
CHEMSPIDER_ID --> 9256
Trivial inputs¶
In order to obtain trivial inputs that do not depend on the thermodynamic state, in wrappers that support the Props1SI
function, you can obtain the trivial parameter (in this case the critical temperature of water) like:
Props1SI(“Tcrit”,”Water”)
In python, the PropsSI
function is overloaded to also accept two inputs:
In [11]: import CoolProp.CoolProp as CP
In [12]: CP.PropsSI("Tcrit","Water")
Out[12]: 647.096
In [13]: CP.PropsSI("Tcrit","REFPROP::WATER")
Out[13]: 647.096
Furthermore, you can in all languages call the PropsSI
function directly using dummy arguments for the other unused parameters:
In [14]: import CoolProp.CoolProp as CP
In [15]: CP.PropsSI("Tcrit","",0,"",0,"Water")
Out[15]: 647.096
PhaseSI function¶
It can be useful to know what the phase of a given state point is. A high-level function called PhaseSI
has been implemented to allow for access to the phase.
In [16]: import CoolProp.CoolProp as CP
In [17]: CP.PhaseSI('P',101325,'Q',0,'Water')
Out[17]: 'twophase'
The phase index (as floating point number) can also be obtained using the PropsSI function. In python you would do:
In [18]: import CoolProp.CoolProp as CP
In [19]: CP.PropsSI('Phase','P',101325,'Q',0,'Water')
Out[19]: 6.0
where you can obtain the integer indices corresponding to the phase flags using the get_phase_index
function:
In [20]: import CoolProp.CoolProp as CP
In [21]: CP.get_phase_index('phase_twophase')
Out[21]: 6
# Or for liquid
In [22]: CP.get_phase_index('phase_liquid')
Out[22]: 0
For a given fluid, the phase can be plotted in T-p coordinates:
(Source code, png, .pdf)
Partial Derivatives¶
First Partial Derivatives for Single-phase States¶
For some applications it can be useful to have access to partial derivatives of thermodynamic properties. A generalized first partial derivative has been implemented into CoolProp, which can be obtained using the PropsSI
function by encoding the desired derivative as a string. The format of the string is d(OF)/d(WRT)|CONSTANT
which is the same as
At the low-level, the CoolProp code calls the function AbstractState::first_partial_deriv(). Refer to the function documentation to see how the generalized derivative works.
Warning
This derivative formulation is currently only valid for homogeneous (single-phase) states. Two phase derivatives are not defined, and are for many combinations, invalid.
Here is an example of calculating the constant pressure specific heat, which is defined by the relation
and called through python
In [23]: import CoolProp.CoolProp as CP
# c_p using c_p
In [24]: CP.PropsSI('C','P',101325,'T',300,'Water')
Out[24]: 4180.6357765560715
# c_p using derivative
In [25]: CP.PropsSI('d(Hmass)/d(T)|P','P',101325,'T',300,'Water')
Out[25]: 4180.6357765560715
It is also possible to call the derivatives directly using the low-level partial derivatives functionality. The low-level routine is in general faster because it avoids the string parsing.
Second Partial Derivatives for Single-Phase States¶
In a similar fashion it is possible to evaluate second derivatives. For instance, the derivative of \(c_p\) with respect to mass-based specific enthalpy at constant pressure could be obtained by
In [26]: import CoolProp.CoolProp as CP
# c_p using derivative
In [27]: CP.PropsSI('d(d(Hmass)/d(T)|P)/d(Hmass)|P','P',101325,'T',300,'Water')
Out[27]: -7.767989468924389e-05
where the inner part d(Hmass)/d(T)|P
is the definition of \(c_p\).
Warning
This derivative formulation is currently only valid for homogeneous (single-phase) states. Two phase derivatives are not defined, and are for many combinations, invalid.
It is also possible to call the derivatives directly using the low-level partial derivatives functionality. The low-level routine is in general faster because it avoids the string parsing.
First Saturation Derivatives¶
It is also possible to retrieve the derivatives along the saturation curves using the high-level interface, encoding the desired derivative as a string just like for the single-phase derivatives.
Warning
This derivative formulation is currently only valid for saturated states where the vapor quality is either 0 or 1.
For instance, to calculate the saturation derivative of enthalpy ALONG the saturated vapor curve, you could do:
In [28]: import CoolProp
In [29]: CoolProp.CoolProp.PropsSI('d(Hmolar)/d(T)|sigma','P',101325,'Q',1,'Water')
Out[29]: 28.427795995713694
It is also possible to call the derivatives directly using the low-level partial derivatives functionality. The low-level routine is in general faster because it avoids the string parsing.
Predefined Mixtures¶
A number of predefined mixtures are included in CoolProp. You can retrieve the list of predefined mixtures by calling get_global_param_string("predefined_mixtures")
which will return a comma-separated list of predefined mixtures. In Python, to get the first 6 mixtures, you would do
In [30]: import CoolProp.CoolProp as CP
In [31]: CP.get_global_param_string('predefined_mixtures').split(',')[0:6]
Out[31]:
['AIR.MIX',
'AMARILLO.MIX',
'Air.mix',
'Amarillo.mix',
'EKOFISK.MIX',
'Ekofisk.mix']
and then to calculate the density of air using the mixture model at 1 atmosphere (=101325 Pa) and 300 K, you could do
In [32]: import CoolProp.CoolProp as CP
In [33]: CP.PropsSI('D','P',101325,'T',300,'Air.mix')
Out[33]: 1.1766922904316655
Exactly the same methodology can be used from other wrappers.
User-Defined Mixtures¶
When using mixtures in CoolProp, you can specify mixture components and composition by encoding the mixture components and mole fractions by doing something like
In [34]: import CoolProp.CoolProp as CP
In [35]: CP.PropsSI('D','T',300,'P',101325,'HEOS::R32[0.697615]&R125[0.302385]')
Out[35]: 2.986886779635724
You can handle ternary and multi-component mixtures in the same fashion, just add the other components to the fluid string with a &
separating components and the fraction of the component in [
and ]
brackets
Reference States¶
Enthalpy and entropy are relative properties! You should always be comparing differences in enthalpy rather than absolute values of the enthalpy or entropy. That said, if can be useful to set the reference state values for enthalpy and entropy to one of a few standard values. This is done by the use of the set_reference_state
function in python, or the set_reference_stateS
function most everywhere else. For documentation of the underlying C++ function, see CoolProp::set_reference_stateS().
Warning
The changing of the reference state should be part of the initialization of your program, and it is not recommended to change the reference state during the course of making calculations
A number of reference states can be used:
IIR
: h = 200 kJ/kg, s=1 kJ/kg/K at 0C saturated liquidASHRAE
: h = 0, s = 0 @ -40C saturated liquidNBP
: h=0, s=0 for saturated liquid at 1 atmosphereDEF
: Go back to the default reference state for the fluid
which can be used like
In [36]: import CoolProp.CoolProp as CP
In [37]: CP.set_reference_state('n-Propane','ASHRAE')
# Should be zero (or very close to it)
In [38]: CP.PropsSI('H', 'T', 233.15, 'Q', 0, 'n-Propane')
Out[38]: 2.928438593838672e-11
# Back to the original value
In [39]: CP.set_reference_state('n-Propane','DEF')
# Should not be zero
In [40]: CP.PropsSI('H', 'T', 233.15, 'Q', 0, 'n-Propane')
Out[40]: 105123.27213761522
For non-standard reference states, you can specify them directly for the given temperature and molar(!) density. Here is an example of setting the enthalpy and entropy at 298.15 K and 1 atm to some specified values
In [41]: import CoolProp.CoolProp as CP
In [42]: Dmolar = CP.PropsSI("Dmolar", "T", 298.15, "P", 101325, "NH3")
In [43]: CP.set_reference_state('NH3', 298.15, Dmolar, -60000.12, 314.159) # fluid, T, D (mol/m^3), h (J/mol), s (J/mol/K)
In [44]: CP.PropsSI("Hmolar", "T", 298.15, "P", 101325, "NH3")
Out[44]: -60000.119999999995
In [45]: CP.PropsSI("Smolar", "T", 298.15, "P", 101325, "NH3")
Out[45]: 314.15900000000005
# Back to the original value
In [46]: CP.set_reference_state('NH3','DEF')
Calling REFPROP¶
If you have the REFPROP library installed, you can call REFPROP in the same way that you call CoolProp, but with REFPROP::
preceding the fluid name. For instance, as in python:
In [47]: import CoolProp.CoolProp as CP
# Using properties from CoolProp to get R410A density
In [48]: CP.PropsSI('D','T',300,'P',101325,'HEOS::R32[0.697615]&R125[0.302385]')
Out[48]: 2.986886779635724
# Using properties from REFPROP to get R410A density
In [49]: CP.PropsSI('D','T',300,'P',101325,'REFPROP::R32[0.697615]&R125[0.302385]')
Out[49]: 2.9868867801892165
Adding Fluids¶
The fluids in CoolProp are all compiled into the library itself, and are given in the JSON format. They are all stored in the dev/fluids
folder relative to the root of the repository. If you want to obtain the JSON data for a fluid from CoolProp, print out a part of it, and then load it back into CoolProp, you could do:
In [50]: import CoolProp.CoolProp as CP
# Get the JSON structure for Water
In [51]: jj = CP.get_fluid_param_string("Water", "JSON")
# Now load it back into CoolProp - Oops! This isn't going to work because it is already there.
In [52]: CP.add_fluids_as_JSON("HEOS", jj)
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
Cell In [52], line 1
----> 1 CP.add_fluids_as_JSON("HEOS", jj)
File CoolProp/CoolProp.pyx:303, in CoolProp.CoolProp.add_fluids_as_JSON()
File CoolProp/CoolProp.pyx:307, in CoolProp.CoolProp.add_fluids_as_JSON()
RuntimeError: Unable to load fluid [Water] due to error: Cannot load fluid [Water:7732-18-5] because it is already in library; index = [93] of [123]; Consider enabling the config boolean variable OVERWRITE_FLUIDS
# Set the configuration variable allowing for overwriting
In [53]: CP.set_config_bool(CP.OVERWRITE_FLUIDS, True)
# Now load it back into CoolProp - Success!
In [54]: CP.add_fluids_as_JSON("HEOS", jj)
# Turn overwriting back off
In [55]: CP.set_config_bool(CP.OVERWRITE_FLUIDS, False)
C++ Sample Code¶
#include "CoolProp.h"
#include <iostream>
#include <stdlib.h>
using namespace CoolProp;
int main() {
// First type (slowest, due to most string processing, exposed in DLL)
std::cout << PropsSI("Dmolar", "T", 298, "P", 1e5, "Propane[0.5]&Ethane[0.5]") << std::endl; // Default backend is HEOS
std::cout << PropsSI("Dmolar", "T", 298, "P", 1e5, "HEOS::Propane[0.5]&Ethane[0.5]") << std::endl;
std::cout << PropsSI("Dmolar", "T", 298, "P", 1e5, "REFPROP::Propane[0.5]&Ethane[0.5]") << std::endl;
// Vector example
std::vector<double> z(2, 0.5);
// Second type (C++ only, a bit faster, allows for vector inputs and outputs)
std::vector<std::string> fluids;
fluids.push_back("Propane");
fluids.push_back("Ethane");
std::vector<std::string> outputs;
outputs.push_back("Dmolar");
std::vector<double> T(1, 298), p(1, 1e5);
std::cout << PropsSImulti(outputs, "T", T, "P", p, "", fluids, z)[0][0] << std::endl; // Default backend is HEOS
std::cout << PropsSImulti(outputs, "T", T, "P", p, "HEOS", fluids, z)[0][0] << std::endl;
// Comment me out if REFPROP is not installed
std::cout << PropsSImulti(outputs, "T", T, "P", p, "REFPROP", fluids, z)[0][0] << std::endl;
// All done return
return EXIT_SUCCESS;
}
C++ Sample Code Output¶
40.8269
40.8269
40.8269
40.8269
40.8269
40.8269
Sample Code¶
In [56]: import CoolProp as CP
In [57]: print(CP.__version__)
6.6.0
In [58]: print(CP.__gitrevision__)
ba21c74fd1c3a4934bbecbf459936983dec424c2
#Import the things you need
In [59]: from CoolProp.CoolProp import PropsSI
# Specific heat (J/kg/K) of 20% ethylene glycol as a function of T
In [60]: PropsSI('C','T',298.15,'P',101325,'INCOMP::MEG-20%')
Out[60]: 3905.2706242925874
# Density of Air at standard atmosphere in kg/m^3
In [61]: PropsSI('D','T',298.15,'P',101325,'Air')
Out[61]: 1.1843184839089664
# Saturation temperature of Water at 1 atm
In [62]: PropsSI('T','P',101325,'Q',0,'Water')
Out[62]: 373.1242958476844
# Saturated vapor enthalpy of R134a at 0C (Q=1)
In [63]: PropsSI('H','T',273.15,'Q',1,'R134a')
Out[63]: 398603.45362765493
# Saturated liquid enthalpy of R134a at 0C (Q=0)
In [64]: PropsSI('H','T',273.15,'Q',0,'R134a')
Out[64]: 199999.98852614488
# Using properties from CoolProp to get R410A density
In [65]: PropsSI('D','T',300,'P',101325,'HEOS::R32[0.697615]&R125[0.302385]')
Out[65]: 2.986886779635724
# Using properties from REFPROP to get R410A density
In [66]: PropsSI('D','T',300,'P',101325,'REFPROP::R32[0.697615]&R125[0.302385]')
Out[66]: 2.9868867801892165
# Check that the same as using pseudo-pure
In [67]: PropsSI('D','T',300,'P',101325,'R410A')
Out[67]: 2.986868076922677
# Using IF97 to get Water saturated vapor density at 100C
In [68]: PropsSI('D','T',400,'Q',1,'IF97::Water')
Out[68]: 1.3692496283046673
# Check the IF97 result using the default HEOS
In [69]: PropsSI('D','T',400,'Q',1,'Water')
Out[69]: 1.3694075410068227
Table of string inputs to PropsSI function¶
Note
Please note that any parameter that is indicated as a trivial parameter can be obtained from the Props1SI
function as shown above in Trivial inputs
Parameter |
Units |
Input/Output |
Trivial |
Description |
---|---|---|---|---|
|
IO |
False |
Reduced density (rho/rhoc) |
|
|
mol/m^3 |
IO |
False |
Molar density |
|
kg/m^3 |
IO |
False |
Mass density |
|
J/mol |
IO |
False |
Molar specific enthalpy |
|
J/kg |
IO |
False |
Mass specific enthalpy |
|
Pa |
IO |
False |
Pressure |
|
mol/mol |
IO |
False |
Molar vapor quality |
|
J/mol/K |
IO |
False |
Molar specific entropy |
|
J/kg/K |
IO |
False |
Mass specific entropy |
|
IO |
False |
Reciprocal reduced temperature (Tc/T) |
|
|
K |
IO |
False |
Temperature |
|
J/mol |
IO |
False |
Molar specific internal energy |
|
J/kg |
IO |
False |
Mass specific internal energy |
|
O |
True |
Acentric factor |
|
|
O |
False |
Ideal Helmholtz energy |
|
|
O |
False |
Residual Helmholtz energy |
|
|
m/s |
O |
False |
Speed of sound |
|
O |
False |
Second virial coefficient |
|
|
W/m/K |
O |
False |
Thermal conductivity |
|
J/kg/K |
O |
False |
Ideal gas mass specific constant pressure specific heat |
|
J/mol/K |
O |
False |
Ideal gas molar specific constant pressure specific heat |
|
J/mol/K |
O |
False |
Molar specific constant pressure specific heat |
|
O |
False |
Third virial coefficient |
|
|
J/kg/K |
O |
False |
Mass specific constant volume specific heat |
|
J/mol/K |
O |
False |
Molar specific constant volume specific heat |
|
J/kg/K |
O |
False |
Mass specific constant pressure specific heat |
|
O |
False |
Second derivative of ideal Helmholtz energy with delta |
|
|
O |
False |
Third derivative of ideal Helmholtz energy with delta |
|
|
O |
False |
Derivative of ideal Helmholtz energy with delta |
|
|
O |
False |
Derivative of ideal Helmholtz energy with tau |
|
|
O |
False |
Derivative of residual Helmholtz energy with delta |
|
|
O |
False |
Derivative of residual Helmholtz energy with tau |
|
|
O |
False |
Derivative of second virial coefficient with respect to T |
|
|
O |
False |
Derivative of third virial coefficient with respect to T |
|
|
C m |
O |
True |
Dipole moment |
|
O |
True |
Flammability hazard |
|
|
O |
True |
Fraction (mole, mass, volume) maximum value for incompressible solutions |
|
|
O |
True |
Fraction (mole, mass, volume) minimum value for incompressible solutions |
|
|
O |
False |
Fundamental derivative of gas dynamics |
|
|
J/mol/K |
O |
True |
Molar gas constant |
|
J/mol/K |
O |
False |
Residual molar Gibbs energy |
|
J/mol |
O |
False |
Molar specific Gibbs energy |
|
O |
True |
100-year global warming potential |
|
|
O |
True |
20-year global warming potential |
|
|
O |
True |
500-year global warming potential |
|
|
J/kg |
O |
False |
Mass specific Gibbs energy |
|
J/kg |
O |
False |
Mass specific Helmholtz energy |
|
J/mol |
O |
False |
Molar specific Helmholtz energy |
|
O |
True |
Health hazard |
|
|
J/mol/K |
O |
False |
Residual molar enthalpy |
|
O |
False |
Isentropic expansion coefficient |
|
|
1/K |
O |
False |
Isobaric expansion coefficient |
|
1/Pa |
O |
False |
Isothermal compressibility |
|
N/m |
O |
False |
Surface tension |
|
kg/mol |
O |
True |
Molar mass |
|
O |
True |
Ozone depletion potential |
|
|
Pa |
O |
True |
Pressure at the critical point |
|
O |
False |
Phase index as a float |
|
|
O |
True |
Physical hazard |
|
|
O |
False |
Phase identification parameter |
|
|
Pa |
O |
True |
Maximum pressure limit |
|
Pa |
O |
True |
Minimum pressure limit |
|
O |
False |
Prandtl number |
|
|
Pa |
O |
True |
Pressure at the triple point (pure only) |
|
Pa |
O |
True |
Pressure at the reducing point |
|
kg/m^3 |
O |
True |
Mass density at critical point |
|
kg/m^3 |
O |
True |
Mass density at reducing point |
|
mol/m^3 |
O |
True |
Molar density at critical point |
|
mol/m^3 |
O |
True |
Molar density at reducing point |
|
J/mol/K |
O |
False |
Residual molar entropy (sr/R = s(T,rho) - s^0(T,rho)) |
|
K |
O |
True |
Temperature at the critical point |
|
K |
O |
True |
Maximum temperature limit |
|
K |
O |
True |
Minimum temperature limit |
|
K |
O |
True |
Temperature at the triple point |
|
K |
O |
True |
Freezing temperature for incompressible solutions |
|
K |
O |
True |
Temperature at the reducing point |
|
Pa s |
O |
False |
Viscosity |
|
O |
False |
Compressibility factor |