03/10/2022 23:09 High-Level Interface — CoolProp 6.4.

1 documentation

High-Level Interface

Contents

High-Level Interface
PropsSI function
Vapor, Liquid, and Saturation States
Imposing the Phase (Optional)
Fluid information
Trivial inputs
PhaseSI function
Partial Derivatives
Predefined Mixtures
User-Defined Mixtures
Reference States
Calling REFPROP
Adding Fluids
C++ Sample Code
C++ Sample Code Output
Sample Code
Table of string inputs to PropsSI function

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:
www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 1/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Table of inputs to PropsSI function

More examples of the high-level API
⇗ Documentation for all high-level functions exposed

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 ρ as state variables, so T , ρ will always be the fastest inputs. P , T will be a
bit slower (3-10 times), followed by input pairs where neither T nor ρ 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-
www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 2/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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
www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 3/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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_

....: 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

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 4/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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)

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 5/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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

∂ OF ∣
∣
∂ W RT ∣ C ON ST AN T

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

∂h ∣
cp = ∣
∂ T ∣p

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 6/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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 with p

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

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 7/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 8/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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 liquid

ASHRAE : h = 0, s = 0 @ -40C saturated liquid
NBP : h=0, s=0 for saturated liquid at 1 atmosphere
DEF : 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

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

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 9/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

# 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.986886780189218

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)
<ipython-input-52-20a067e85efb> in <module>
----> 1 CP.add_fluids_as_JSON("HEOS", jj)

CoolProp/CoolProp.pyx in CoolProp.CoolProp.add_fluids_as_JSON()

CoolProp/CoolProp.pyx in CoolProp.CoolProp.add_fluids_as_JSON()

RuntimeError: Unable to load fluid [Water] due to error: Cannot load fluid [Water:7732-18-5]

# 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)

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 10/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

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; /
std::cout << PropsSI("Dmolar","T",298,"P",1e5,"HEOS::Propane[0.5]&Ethane[0.5]") << std::e
std::cout << PropsSI("Dmolar","T",298,"P",1e5,"REFPROP::Propane[0.5]&Ethane[0.5]") << std
// 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; // D
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::end
// 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.4.1

In [58]: print(CP.__gitrevision__)
f5ebb4e655add4c23bb327ab5209f3dbf919bc6d

#Import the things you need

In [59]: from CoolProp.CoolProp import PropsSI

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 11/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

# 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.986886780189218

# 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

DELTA , Delta IO False Reduced density

(rho/rhoc)
DMOLAR , Dmolar mol/m^3 IO False Molar density
D , DMASS , Dmass kg/m^3 IO False Mass density
HMOLAR , Hmolar J/mol IO False Molar specific
enthalpy

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 12/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Parameter Units Input/Output Trivial Description

H , HMASS , Hmass J/kg IO False Mass specific

enthalpy
P Pa IO False Pressure
Q mol/mol IO False Mass vapor
quality
SMOLAR , Smolar J/mol/K IO False Molar specific
entropy
S , SMASS , Smass J/kg/K IO False Mass specific
entropy
TAU , Tau IO False Reciprocal
reduced
temperature
(Tc/T)
T K IO False Temperature
UMOLAR , Umolar J/mol IO False Molar specific
internal energy
U , UMASS , Umass J/kg IO False Mass specific
internal energy
ACENTRIC , acentric O True Acentric factor
ALPHA0 , alpha0 O False Ideal Helmholtz
energy
ALPHAR , alphar O False Residual
Helmholtz
energy
A , SPEED_OF_SOUND , speed_of_sound m/s O False Speed of sound
BVIRIAL , Bvirial O False Second virial
coefficient
CONDUCTIVITY , L , conductivity W/m/K O False Thermal
conductivity
CP0MASS , Cp0mass J/kg/K O False Ideal gas mass
specific constant
pressure specific
heat
CP0MOLAR , Cp0molar J/mol/K O False Ideal gas molar
specific constant
pressure specific
heat

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 13/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Parameter Units Input/Output Trivial Description

CPMOLAR , Cpmolar J/mol/K O False Molar specific

constant
pressure specific
heat
CVIRIAL , Cvirial O False Third virial
coefficient
CVMASS , Cvmass , O J/kg/K O False Mass specific
constant volume
specific heat
CVMOLAR , Cvmolar J/mol/K O False Molar specific
constant volume
specific heat
C , CPMASS , Cpmass J/kg/K O False Mass specific
constant
pressure specific
heat
DALPHA0_DDELTA_CONSTTAU , O False Derivative of
dalpha0_ddelta_consttau ideal Helmholtz
energy with
delta
DALPHA0_DTAU_CONSTDELTA , O False Derivative of
dalpha0_dtau_constdelta ideal Helmholtz
energy with tau
DALPHAR_DDELTA_CONSTTAU , O False Derivative of
dalphar_ddelta_consttau residual
Helmholtz
energy with
delta
DALPHAR_DTAU_CONSTDELTA , O False Derivative of
dalphar_dtau_constdelta residual
Helmholtz
energy with tau
DBVIRIAL_DT , dBvirial_dT O False Derivative of
second virial
coefficient with
respect to T
DCVIRIAL_DT , dCvirial_dT O False Derivative of
third virial
coefficient with
respect to T
DIPOLE_MOMENT , dipole_moment Cm O True Dipole moment
FH O True Flammability
hazard

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 14/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Parameter Units Input/Output Trivial Description

FRACTION_MAX , fraction_max O True Fraction (mole,

mass, volume)
maximum value
for
incompressible
solutions
FRACTION_MIN , fraction_min O True Fraction (mole,
mass, volume)
minimum value
for
incompressible
solutions
FUNDAMENTAL_DERIVATIVE_OF_GAS_DYNAMICS , O False Fundamental
fundamental_derivative_of_gas_dynamics derivative of gas
dynamics
GAS_CONSTANT , gas_constant J/mol/K O True Molar gas
constant
GMOLAR_RESIDUAL , Gmolar_residual J/mol/K O False Residual molar
Gibbs energy
GMOLAR , Gmolar J/mol O False Molar specific
Gibbs energy
GWP100 O True 100-year global
warming
potential
GWP20 O True 20-year global
warming
potential
GWP500 O True 500-year global
warming
potential
G , GMASS , Gmass J/kg O False Mass specific
Gibbs energy
HELMHOLTZMASS , Helmholtzmass J/kg O False Mass specific
Helmholtz
energy
HELMHOLTZMOLAR , Helmholtzmolar J/mol O False Molar specific
Helmholtz
energy
HH O True Health hazard
HMOLAR_RESIDUAL , Hmolar_residual J/mol/K O False Residual molar
enthalpy

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 15/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Parameter Units Input/Output Trivial Description

ISENTROPIC_EXPANSION_COEFFICIENT , O False Isentropic

isentropic_expansion_coefficient expansion
coefficient
ISOBARIC_EXPANSION_COEFFICIENT , 1/K O False Isobaric
isobaric_expansion_coefficient expansion
coefficient
ISOTHERMAL_COMPRESSIBILITY , 1/Pa O False Isothermal
isothermal_compressibility compressibility
I , SURFACE_TENSION , surface_tension N/m O False Surface tension
M , MOLARMASS , MOLAR_MASS , MOLEMASS , kg/mol O True Molar mass
molar_mass , molarmass , molemass

ODP O True Ozone depletion

potential
PCRIT , P_CRITICAL , Pcrit , p_critical , Pa O True Pressure at the
pcrit critical point
PHASE , Phase O False Phase index as a
float
PH O True Physical hazard
PIP O False Phase
identification
parameter
PMAX , P_MAX , P_max , pmax Pa O True Maximum
pressure limit
PMIN , P_MIN , P_min , pmin Pa O True Minimum
pressure limit
PRANDTL , Prandtl O False Prandtl number
PTRIPLE , P_TRIPLE , p_triple , ptriple Pa O True Pressure at the
triple point (pure
only)
P_REDUCING , p_reducing Pa O True Pressure at the
reducing point
RHOCRIT , RHOMASS_CRITICAL , rhocrit , kg/m^3 O True Mass density at
rhomass_critical critical point
RHOMASS_REDUCING , rhomass_reducing kg/m^3 O True Mass density at
reducing point
RHOMOLAR_CRITICAL , rhomolar_critical mol/m^3 O True Molar density at
critical point
RHOMOLAR_REDUCING , rhomolar_reducing mol/m^3 O True Molar density at
reducing point

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 16/17
03/10/2022 23:09 High-Level Interface — CoolProp 6.4.1 documentation

Parameter Units Input/Output Trivial Description

SMOLAR_RESIDUAL , Smolar_residual J/mol/K O False Residual molar

entropy (sr/R =
s(T,rho) -
s^0(T,rho))
TCRIT , T_CRITICAL , T_critical , Tcrit K O True Temperature at
the critical point
TMAX , T_MAX , T_max , Tmax K O True Maximum
temperature
limit
TMIN , T_MIN , T_min , Tmin K O True Minimum
temperature
limit
TTRIPLE , T_TRIPLE , T_triple , Ttriple K O True Temperature at
the triple point
T_FREEZE , T_freeze K O True Freezing
temperature for
incompressible
solutions
T_REDUCING , T_reducing K O True Temperature at
the reducing
point
V , VISCOSITY , viscosity Pa s O False Viscosity
Z O False Compressibility
factor

www.coolprop.org/coolprop/HighLevelAPI.html#table-of-string-inputs-to-propssi-function 17/17