Detailed Description

This file contains flash routines in which the state is unknown, and a solver of some kind must be used to obtain temperature and density, the two state variables upon which the equation of state is based.

This file contains derivatives needed in the mixture model. The derivatives are quite nasty, and there are a lot of them, so they are put in this file for cleanness. The MixtureDerivatives class is a friend class of the HelmholtzEOSMixtureBackend, so it can access all the private members of the HelmholtzEOSMixtureBackend class

Out-of-line, JSON-consuming construction for SuperAncillary.

The installed header include/CoolProp/superancillary/superancillary.h keeps all templated, perf-critical evaluation inline but carries NO nlohmann::json type, so consumers do not need nlohmann to compile against CoolProp's public headers. The string-blob constructor's definition lives here (where nlohmann is available) and is explicitly instantiated for the one ArrayType used across the codebase.

Namespaces
namespace	CubicLibrary

namespace	CubicSuperAncillary

namespace	detail

namespace	PCSAFTLibrary

namespace	Plot

namespace	region

namespace	SaturationSolvers

namespace	sbtl

namespace	StabilityRoutines

namespace	superancillary

namespace	svd

namespace	tests

Classes
class	AbstractCubicBackend

class	AbstractState
	The mother of all state classes. More...

class	AbstractStateGenerator

struct	Ancillaries

struct	backend_family_info

struct	backend_info

class	BackendInformation

class	BackendLibrary

class	BaseHelmholtzContainer

class	BaseHelmholtzTerm
	The base class class for the Helmholtz energy terms. More...

struct	BibTeXKeysStruct

class	BicubicBackend

class	BoyleCurveTracer

class	CacheArray

class	CacheArrayElement

class	CachedElement

class	CellCoeffs

struct	ConductivityCriticalSimplifiedOlchowySengersData

struct	ConductivityCriticalVariables

struct	ConductivityDiluteEta0AndPolyData

struct	ConductivityDiluteRatioPolynomialsData

struct	ConductivityDiluteVariables

struct	ConductivityECSVariables

struct	ConductivityResidualPolynomialAndExponentialData

struct	ConductivityResidualPolynomialData

struct	ConductivityResidualVariables

class	Configuration

class	ConfigurationItem

class	ConstantReducingFunction
	A constant reducing function that does not vary with composition. Think for instance the reducing function for the cubic EOS. More...

class	CoolPropBaseError

class	CoolPropError

class	CoolPropFluid
	A thermophysical property provider for critical and reducing values as well as derivatives of Helmholtz energy. More...

class	CorrespondingStatesTerm

struct	CriticalRegionSplines

struct	CriticalState

class	CubicResidualHelmholtz

class	CurveTracer

struct	delim

class	DepartureFunction
	The abstract base class for departure functions used in the excess part of the Helmholtz energy. More...

class	DQ_flash_residual

struct	EnvironmentalFactorsStruct

struct	EOSLimits
	A set of limits for the eos parameters. More...

class	EquationOfState
	The core class for an equation of state. More...

class	ExcessTerm

class	ExponentialDepartureFunction
	A polynomial/exponential departure function. More...

struct	FactoryOptionsParseResult

class	FlashRoutines

class	fpu_guard

class	FuncWrapper1D

class	FuncWrapper1DWithDeriv

class	FuncWrapper1DWithThreeDerivs

class	FuncWrapper1DWithTwoDerivs

class	FuncWrapperND

class	GaussianExponentialDepartureFunction
	A hybrid gaussian with temperature and density dependence along with. More...

class	GeneratorInitializer

class	GERG2008DepartureFunction
	The departure function used by the GERG-2008 formulation. More...

class	GERG2008ReducingFunction
	The reducing function model of GERG-2008. More...

class	GuessesStructure

struct	HelmholtzDerivatives

class	HelmholtzEOSBackend

class	HelmholtzEOSMixtureBackend

class	HEOSGenerator

class	IdealCurveTracer

class	IdealHelmholtzContainer
	More...

class	IdealHelmholtzCP0Constant

class	IdealHelmholtzCP0PolyT

class	IdealHelmholtzEnthalpyEntropyOffset
	The term in the EOS used to shift the reference state of the fluid. More...

class	IdealHelmholtzGERG2004Cosh

class	IdealHelmholtzGERG2004Sinh

class	IdealHelmholtzLead
	The leading term in the EOS used to set the desired reference state. More...

class	IdealHelmholtzLogTau

class	IdealHelmholtzPlanckEinsteinGeneralized

class	IdealHelmholtzPower

class	IF97Backend

class	IF97BackendGenerator

class	IncompressibleBackend

class	IncompressibleBackendGenerator

struct	IncompressibleData

class	IncompressibleFluid
	A property provider for incompressible solutions and pure fluids. More...

struct	input_pair_info

class	InputPairInformation

class	JouleInversionCurveTracer

class	JouleThomsonCurveTracer

class	JSONFluidLibrary
	A container for the fluid parameters for the CoolProp fluids. More...

class	JSONIncompressibleLibrary
	A container for the fluid parameters for the incompressible fluids. More...

class	L0CurveTracer

class	LemmonAirHFCReducingFunction
	Reducing function converter for dry air and HFC blends. More...

class	LogPHTable
	This class holds the single-phase data for a log(p)-h gridded table. More...

class	LogPTTable
	This class holds the single-phase data for a log(p)-T gridded table. More...

class	MeltingCaloric

struct	MeltingLinePiecewisePolynomialInThetaData

class	MeltingLinePiecewisePolynomialInThetaSegment
	The evaluator class for a melting curve formed of segments in the form. More...

struct	MeltingLinePiecewisePolynomialInTrData

class	MeltingLinePiecewisePolynomialInTrSegment
	The evaluator class for a melting curve formed of segments in the form. More...

struct	MeltingLinePiecewiseSimonData

struct	MeltingLinePiecewiseSimonSegment

class	MeltingLineVariables

class	MixtureBinaryPairLibrary
	A library of binary pair parameters for the mixture. More...

class	MixtureDepartureFunctionsLibrary
	A container for the departure functions for CoolProp mixtures. More...

class	MixtureDerivatives

class	MixtureParameters

class	MoleFractions

class	OneDimObjective
	This class is the objective function for the one-dimensional solver used to find the first intersection with the L1*=0 contour. More...

struct	output_parameter

class	PackablePhaseEnvelopeData

struct	parameter_info

class	ParameterInformation

class	PCSAFTBackend

class	PCSAFTFluid

class	PCSAFTGenerator

struct	PCSAFTValues

class	PengRobinsonBackend

struct	phase_info

class	PhaseEnvelopeData
	A data structure to hold the data for a phase envelope. More...

class	PhaseEnvelopeRoutines

class	PhaseInformation

class	Poly2DFracIntResidual

class	Poly2DFracResidual

class	Poly2DResidual

class	Polynomial2D
	The base class for all Polynomials. More...

class	Polynomial2DFrac
	A class for polynomials starting at an arbitrary degree. More...

class	PredefinedMixturesLibrary
	A library of predefined mixtures. More...

class	PRGenerator

class	PureFluidSaturationTableData
	This class holds the data for a two-phase table that is log spaced in p. More...

class	PY_singlephase_flash_resid

class	RachfordRiceResidual

class	ReducingFunction
	Abstract base class for reducing function An abstract base class for the reducing function to allow for Lemmon-Jacobsen, GERG, or other reducing function to yield the reducing parameters \(\rho_r\) and \(T_r\). More...

struct	REFPROP_binary_element
	A Data structure for holding BIP coming from REFPROP. More...

struct	REFPROP_departure_function
	A data structure for holding departure functions coming from REFPROP. More...

class	REFPROPBackend

class	REFPROPGenerator

class	REFPROPMixtureBackend

class	ResidualHelmholtz

class	ResidualHelmholtzContainer

class	ResidualHelmholtzGaoB

class	ResidualHelmholtzGeneralizedCubic

class	ResidualHelmholtzGeneralizedExponential
	A generalized residual helmholtz energy container that can deal with a wide range of terms which can be converted to this general form. More...

struct	ResidualHelmholtzGeneralizedExponentialElement

class	ResidualHelmholtzNonAnalytic

struct	ResidualHelmholtzNonAnalyticElement

class	ResidualHelmholtzSAFTAssociating

class	ResidualHelmholtzXiangDeiters
	The generalized Lee-Kesler formulation of Xiang & Deiters: doi:10.1016/j.ces.2007.11.029. More...

class	SaturationAncillaryFunction

struct	scheme_info

class	SchemeInformation

struct	SimpleState

class	SinglePhaseGriddedTableData
	This class holds the data for a single-phase interpolation table that is regularly spaced. More...

class	solver_DP_resid

class	solver_TP_resid

class	SolverTPResid

class	SpinodalData

class	SRKBackend

class	SRKGenerator

struct	SsatSimpleState
	A modified class for the state point at the maximum saturation entropy on the vapor curve. More...

class	SurfaceTensionCorrelation

class	SVDSBTLBackend

class	TabularBackend
	This class contains the general code for tabular backends (TTSE, bicubic, etc.) More...

class	TabularDataLibrary

class	TabularDataSet
	This class contains the data for one set of Tabular data including single-phase and two-phase data. More...

struct	THERM0dllOutputs

class	TransportPropertyData

class	TransportRoutines

class	TTSEBackend

class	ValueErrorSpec

struct	ViscosityChungData

struct	ViscosityDiluteCollisionIntegralPowersOfTstarData

struct	ViscosityDiluteGasCollisionIntegralData
	Variables for the dilute gas part. More...

struct	ViscosityDiluteGasPowersOfT

struct	ViscosityDiluteGasPowersOfTr

struct	ViscosityDiluteVariables

struct	ViscosityECSVariables

struct	ViscosityFrictionTheoryData

struct	ViscosityHigherOrderVariables

struct	ViscosityInitialDensityEmpiricalData

struct	ViscosityInitialDensityVariables

struct	ViscosityModifiedBatschinskiHildebrandData

struct	ViscosityRainWaterFriendData

struct	ViscosityRhoSrVariables

class	VTPRBackend

class	VTPRGenerator

Typedefs
using	STLMatrix = std::vector< std::vector< CoolPropDbl > >

using	DepartureFunctionPointer = shared_ptr< DepartureFunction >

using	mat = std::vector< std::vector< double > >
	This class implements bicubic interpolation, as very clearly laid out by the page on wikipedia: http://en.wikipedia.org/wiki/Bicubic_interpolation. More...

using	NotImplementedError = CoolPropError< CoolPropBaseError::eNotImplemented >

using	SolutionError = CoolPropError< CoolPropBaseError::eSolution >

using	AttributeError = CoolPropError< CoolPropBaseError::eAttribute >

using	OutOfRangeError = CoolPropError< CoolPropBaseError::eOutOfRange >

using	ValueError = CoolPropError< CoolPropBaseError::eValue >

using	KeyError = CoolPropError< CoolPropBaseError::eKey >

using	HandleError = CoolPropError< CoolPropBaseError::eHandle >

using	UnableToLoadError = CoolPropError< CoolPropBaseError::eUnableToLoad >

using	DirectorySizeError = CoolPropError< CoolPropBaseError::eDirectorySize >

using	WrongFluidError = ValueErrorSpec< CoolPropBaseError::eWrongFluid >

using	CompositionError = ValueErrorSpec< CoolPropBaseError::eComposition >

using	InputError = ValueErrorSpec< CoolPropBaseError::eInput >

using	NotAvailableError = ValueErrorSpec< CoolPropBaseError::eNotAvailable >

using	MultipleSolutionsError = ValueErrorSpec< CoolPropBaseError::eMultipleSolutions >

Enumerations
enum	x_N_dependency_flag { XN_INDEPENDENT , XN_DEPENDENT }

enum	parameters : int { INVALID_PARAMETER = 0 , igas_constant , imolar_mass , iacentric_factor , irhomolar_reducing , irhomolar_critical , iT_reducing , iT_critical , irhomass_reducing , irhomass_critical , iP_critical , iP_reducing , iT_triple , iP_triple , iT_min , iT_max , iP_max , iP_min , idipole_moment , iT , iP , iQ , iQmass , iTau , iDelta , iDmolar , iHmolar , iSmolar , iCpmolar , iCp0molar , iCvmolar , iUmolar , iGmolar , iHelmholtzmolar , iHmolar_residual , iSmolar_residual , iGmolar_residual , iHmolar_idealgas , iSmolar_idealgas , iUmolar_idealgas , iDmass , iHmass , iSmass , iCpmass , iCp0mass , iCvmass , iUmass , iGmass , iHelmholtzmass , iHmass_idealgas , iSmass_idealgas , iUmass_idealgas , iviscosity , iconductivity , isurface_tension , iPrandtl , ispeed_sound , iisothermal_compressibility , iisobaric_expansion_coefficient , iisentropic_expansion_coefficient , ifundamental_derivative_of_gas_dynamics , ialphar , idalphar_dtau_constdelta , idalphar_ddelta_consttau , ialpha0 , idalpha0_dtau_constdelta , idalpha0_ddelta_consttau , id2alpha0_ddelta2_consttau , id3alpha0_ddelta3_consttau , iBvirial , iCvirial , idBvirial_dT , idCvirial_dT , iZ , iPIP , ifraction_min , ifraction_max , iT_freeze , iGWP20 , iGWP100 , iGWP500 , iFH , iHH , iPH , iODP , iPhase , iundefined_parameter }

enum	phases : int { iphase_liquid , iphase_supercritical , iphase_supercritical_gas , iphase_supercritical_liquid , iphase_critical_point , iphase_gas , iphase_twophase , iphase_unknown , iphase_not_imposed }
	These are constants for the phases of the fluid. More...

enum	fast_evaluate_status : int { fast_evaluate_ok = 0 , fast_evaluate_out_of_range = 1 , fast_evaluate_two_phase_disallowed = 2 , fast_evaluate_unsupported_input = 3 , fast_evaluate_unsupported_output = 4 , fast_evaluate_internal_error = 5 }
	Per-point status codes for AbstractState::fast_evaluate. Zero means success. More...

enum	schemes { i1 , i2a , i2b , i3a , i3b , i4a , i4b , i4c }
	Constants for the different PC-SAFT association schemes (see Huang and Radosz 1990) More...

enum	composition_types { IFRAC_MASS , IFRAC_MOLE , IFRAC_VOLUME , IFRAC_UNDEFINED , IFRAC_PURE }
	These are constants for the compositions. More...

enum	fluid_types { FLUID_TYPE_PURE , FLUID_TYPE_PSEUDOPURE , FLUID_TYPE_REFPROP , FLUID_TYPE_INCOMPRESSIBLE_LIQUID , FLUID_TYPE_INCOMPRESSIBLE_SOLUTION , FLUID_TYPE_UNDEFINED }
	These are unit types for the fluid. More...

enum	input_pairs : int { INPUT_PAIR_INVALID = 0 , QT_INPUTS , QmassT_INPUTS , PQ_INPUTS , PQmass_INPUTS , QSmolar_INPUTS , QmassSmolar_INPUTS , QSmass_INPUTS , QmassSmass_INPUTS , HmolarQ_INPUTS , HmolarQmass_INPUTS , HmassQ_INPUTS , HmassQmass_INPUTS , DmolarQ_INPUTS , DmolarQmass_INPUTS , DmassQ_INPUTS , DmassQmass_INPUTS , PT_INPUTS , DmassT_INPUTS , DmolarT_INPUTS , HmolarT_INPUTS , HmassT_INPUTS , SmolarT_INPUTS , SmassT_INPUTS , TUmolar_INPUTS , TUmass_INPUTS , DmassP_INPUTS , DmolarP_INPUTS , HmassP_INPUTS , HmolarP_INPUTS , PSmass_INPUTS , PSmolar_INPUTS , PUmass_INPUTS , PUmolar_INPUTS , HmassSmass_INPUTS , HmolarSmolar_INPUTS , SmassUmass_INPUTS , SmolarUmolar_INPUTS , DmassHmass_INPUTS , DmolarHmolar_INPUTS , DmassSmass_INPUTS , DmolarSmolar_INPUTS , DmassUmass_INPUTS , DmolarUmolar_INPUTS }
	These are input pairs that can be used for the update function (in each pair, input keys are sorted alphabetically) More...

enum	backend_families : int { INVALID_BACKEND_FAMILY = 0 , HEOS_BACKEND_FAMILY , REFPROP_BACKEND_FAMILY , INCOMP_BACKEND_FAMILY , IF97_BACKEND_FAMILY , TREND_BACKEND_FAMILY , TTSE_BACKEND_FAMILY , BICUBIC_BACKEND_FAMILY , SRK_BACKEND_FAMILY , PR_BACKEND_FAMILY , VTPR_BACKEND_FAMILY , PCSAFT_BACKEND_FAMILY , SVDSBTL_BACKEND_FAMILY }
	The structure is taken directly from the AbstractState class. More...

enum	backends : int { INVALID_BACKEND = 0 , HEOS_BACKEND_PURE , HEOS_BACKEND_MIX , REFPROP_BACKEND_PURE , REFPROP_BACKEND_MIX , INCOMP_BACKEND , IF97_BACKEND , TREND_BACKEND , TTSE_BACKEND , BICUBIC_BACKEND , SRK_BACKEND , PR_BACKEND , VTPR_BACKEND , PCSAFT_BACKEND , SVDSBTL_BACKEND }

Functions
BackendLibrary &	get_backend_library ()

void	register_backend (const backend_families &bf, const shared_ptr< AbstractStateGenerator > &gen)

void	get_dT_drho (AbstractState &AS, parameters index, CoolPropDbl &dT, CoolPropDbl &drho)

void	get_dT_drho_second_derivatives (AbstractState &AS, int index, CoolPropDbl &dT2, CoolPropDbl &drho_dT, CoolPropDbl &drho2)

void	get_Henrys_coeffs_FP (const std::string &CAS, double &A, double &B, double &C, double &Tmin, double &Tmax)

void	load ()

JSONFluidLibrary &	get_library ()
	Get a reference to the library instance. More...

CoolPropFluid	get_fluid (const std::string &fluid_string)
	Get the fluid structure. More...

std::string	get_fluid_as_JSONstring (const std::string &indentifier)
	Get the fluid as a JSON string, suitable for modification and reloading. More...

std::string	get_fluid_list ()
	Get a comma-separated-list of fluids that are included. More...

void	set_fluid_enthalpy_entropy_offset (const std::string &fluid, double delta_a1, double delta_a2, const std::string &ref)
	Set the internal enthalpy and entropy offset variables. More...

int	get_debug_level ()

std::string	vecstring_to_string (const std::vector< std::string > &a)
	Templates for turning vectors (1D-matrices) into strings. More...

void	get_dT_drho (HelmholtzEOSMixtureBackend *HEOS, parameters index, CoolPropDbl &dT, CoolPropDbl &drho)

std::shared_ptr< MeltingCaloric >	get_melting_caloric_cached (HelmholtzEOSMixtureBackend &H)

std::string	get_csv_predefined_mixtures ()
	Get a comma-separated list of predefined mixtures in CoolProp. More...

bool	is_predefined_mixture (const std::string &name, Dictionary &dict)
	Get the parameters for a predefined mixture - R410A, R404A, etc. if the mixture is predefined. More...

void	set_predefined_mixtures (const std::string &string_data)
	Set predefined mixtures at runtime. More...

void	apply_simple_mixing_rule (const std::string &identifier1, const std::string &identifier2, const std::string &rule)
	Add a simple mixing rule. More...

std::string	get_csv_mixture_binary_pairs ()
	Get a comma-separated list of CAS code pairs. More...

std::string	get_mixture_binary_pair_data (const std::string &CAS1, const std::string &CAS2, const std::string &param)
	Get a string for the given binary pair. More...

void	set_mixture_binary_pair_data (const std::string &CAS1, const std::string &CAS2, const std::string &param, const double val)
	Set a parameter for the given binary pair. More...

std::string	get_reducing_function_name (const std::string &CAS1, const std::string &CAS2)

void	set_interaction_parameters (const std::string &string_data)
	Set the interaction parameters from a string format. More...

DepartureFunction *	get_departure_function (const std::string &Name)
	Get the allocated Departure function for a given departure function name. More...

void	parse_HMX_BNC (const std::string &s, std::vector< REFPROP_binary_element > &BIP, std::vector< REFPROP_departure_function > &functions)

void	set_departure_functions (const std::string &string_data)
	Set the departure functions in the departure function library from a string format. More...

CoolPropDbl	sign (CoolPropDbl x)

void	load_incompressible_library ()

JSONIncompressibleLibrary &	get_incompressible_library ()
	Get a reference to the library instance. More...

IncompressibleFluid &	get_incompressible_fluid (const std::string &fluid_string)
	Get the fluid structure returned as a reference. More...

std::string	get_incompressible_list_pure ()
	Return a comma-separated list of incompressible pure fluid names. More...

std::string	get_incompressible_list_solution ()
	Return a comma-separated list of solution names. More...

std::string	get_mixture_binary_pair_pcsaft (const std::string &CAS1, const std::string &CAS2, const std::string &key)

void	set_mixture_binary_pair_pcsaft (const std::string &CAS1, const std::string &CAS2, const std::string &key, const double value)

bool	force_load_REFPROP ()

bool	force_unload_REFPROP ()

void	REFPROP_SETREF (char hrf, int ixflag, double x0, double &h0, double &s0, double &T0, double &p0, int &ierr, char *herr, int l1, int l2)

template<typename T >
void	load_table (T &table, const std::string &path_to_tables, const std::string &filename)

template<typename T >
void	write_table (const T &table, const std::string &path_to_tables, const std::string &name)

void	mass_to_molar (parameters &param, double &conversion_factor, double molar_mass)
	Get a conversion factor from mass to molar if needed. More...

std::string	config_key_to_string (configuration_keys keys)
	Convert the configuration key to a string in a 1-1 representation. More...

std::string	config_key_description (configuration_keys keys)
	Return a string description of the configuration key. More...

std::string	config_key_description (const std::string &key)
	Return a string description of the configuration key (with the key passed as a string) More...

configuration_keys	config_string_to_key (const std::string &s)
	Go from string to enum key. More...

Configuration *	_get_config ()
	A helper function to ensure that configuration is not accessed before it is initialized (was formerly static) More...

void	set_config_bool (configuration_keys key, bool val)
	Set the value of a boolean configuration value. More...

void	set_config_int (configuration_keys key, int val)
	Set the value of an integer configuration value. More...

void	set_config_double (configuration_keys key, double val)
	Set the value of a double configuration value. More...

void	set_config_string (configuration_keys key, const std::string &val)
	Set the value of a string configuration value. More...

bool	get_config_bool (configuration_keys key)
	Return the value of a boolean key from the configuration. More...

int	get_config_int (configuration_keys key)
	Return the value of an integer key from the configuration. More...

double	get_config_double (configuration_keys key)
	Return the value of a double configuration key. More...

std::string	get_config_string (configuration_keys key)
	Return the value of a string configuration key. More...

std::string	get_config_as_json_string ()
	Get all the values in the configuration as a json-formatted string. More...

void	set_config_as_json_string (const std::string &s)
	Set the entire configuration based on a json-formatted string. More...

void	set_debug_level (int level)

void	set_warning_string (const std::string &warning)

void	set_error_string (const std::string &error)

bool	has_backend_in_string (const std::string &fluid_string, std::size_t &i)

void	extract_backend (std::string fluid_string, std::string &backend, std::string &fluid)
	Extract the backend from a string - something like "HEOS::Water" would split to "HEOS" and "Water". If no backend is specified, the backend will be set to "?". More...

bool	has_fractions_in_string (const std::string &fluid_string)

bool	has_solution_concentration (const std::string &fluid_string)

std::string	extract_fractions (const std::string &fluid_string, std::vector< double > &fractions)
	Extract fractions (molar, mass, etc.) encoded in the string if any. More...

void	_PropsSI_initialize (const std::string &backend, const std::vector< std::string > &fluid_names, const std::vector< double > &z, shared_ptr< AbstractState > &State)

void	_PropsSI_outputs (shared_ptr< AbstractState > &State, const std::vector< output_parameter > &output_parameters, CoolProp::input_pairs input_pair, const std::vector< double > &in1, const std::vector< double > &in2, std::vector< std::vector< double > > &IO)

bool	StripPhase (std::string &Name, shared_ptr< AbstractState > &State)

void	_PropsSImulti (const std::vector< std::string > &Outputs, const std::string &Name1, const std::vector< double > &Prop1, const std::string &Name2, const std::vector< double > &Prop2, const std::string &backend, const std::vector< std::string > &fluids, const std::vector< double > &fractions, std::vector< std::vector< double > > &IO)

std::vector< std::vector< double > >	PropsSImulti (const std::vector< std::string > &Outputs, const std::string &Name1, const std::vector< double > &Prop1, const std::string &Name2, const std::vector< double > &Prop2, const std::string &backend, const std::vector< std::string > &fluids, const std::vector< double > &fractions)
	Get a matrix of outputs for a given input. Can handle both vector inputs as well as a vector of output strings. More...

double	PropsSI (const std::string &Output, const std::string &Name1, double Prop1, const std::string &Name2, double Prop2, const std::string &FluidName)

bool	add_fluids_as_JSON (const std::string &backend, const std::string &fluidstring)
	Add fluids as a JSON-formatted string. More...

void	Skip_if_No_REFPROP ()
	A function to skip tests that require REFPROPMixtureBackend in environments where it is not supported (e.g., CI builds on GitHub) More...

double	Props1SI (std::string FluidName, std::string Output)

std::vector< std::vector< double > >	Props1SImulti (const std::vector< std::string > &Outputs, const std::string &backend, const std::vector< std::string > &fluids, const std::vector< double > &fractions)
	Get a matrix of outputs that do not depend on the thermodynamic state - this is a convenience function that does the call PropsSImulti(Outputs, "", {0}, "", {0}, backend, fluids, fractions) More...

bool	is_valid_fluid_string (const std::string &fluidstring)
	Check if the fluid name is valid. More...

double	saturation_ancillary (const std::string &fluid_name, const std::string &output, int Q, const std::string &input, double value)

void	set_reference_stateS (const std::string &FluidName, const std::string &reference_state)
	Set the reference state based on a string representation. More...

void	set_reference_stateD (const std::string &FluidName, double T, double rhomolar, double hmolar0, double smolar0)

std::string	get_global_param_string (const std::string &ParamName)

std::string	get_fluid_param_string (const std::string &FluidName, const std::string &ParamName)
	Get a string for a value from a fluid (numerical values for the fluid can be obtained from Props1SI function) More...

std::string	phase_lookup_string (phases Phase)

std::string	PhaseSI (const std::string &Name1, double Prop1, const std::string &Name2, double Prop2, const std::string &FluidName)

const ParameterInformation &	get_parameter_information ()

bool	is_trivial_parameter (int key)
	Returns true if the input is trivial (constants, critical parameters, etc.) More...

std::string	get_parameter_information (int key, std::string_view info)

std::string	get_csv_parameter_list ()
	Return a list of parameters. More...

bool	is_valid_parameter (const std::string &name, parameters &iOutput)
	Returns true if a valid parameter, and sets value in the variable iOutput. More...

bool	is_valid_first_derivative (const std::string &name, parameters &iOf, parameters &iWrt, parameters &iConstant)

bool	is_valid_first_saturation_derivative (const std::string &name, parameters &iOf, parameters &iWrt)

bool	is_valid_second_derivative (const std::string &name, parameters &iOf1, parameters &iWrt1, parameters &iConstant1, parameters &iWrt2, parameters &iConstant2)

const PhaseInformation &	get_phase_information ()

const std::string &	get_phase_short_desc (phases phase)

bool	is_valid_phase (const std::string &phase_name, phases &iOutput)

phases	get_phase_index (const std::string &param_name)
	Return the enum key corresponding to the phase name ("phase_liquid" for instance) More...

const SchemeInformation &	get_scheme_information ()

const std::string &	get_scheme_short_desc (schemes scheme)

bool	is_valid_scheme (const std::string &scheme_name, schemes &iOutput)

schemes	get_scheme_index (const std::string &scheme_name)
	Return the enum key corresponding to the association scheme name ("2B" for instance) More...

parameters	get_parameter_index (const std::string &param_name)
	Return the enum key corresponding to the parameter name ("Dmolar" for instance) More...

const InputPairInformation &	get_input_pair_information ()

input_pairs	get_input_pair_index (const std::string &input_pair_name)
	Get the input pair index associated with its string representation. More...

const std::string &	get_input_pair_short_desc (input_pairs pair)
	Return the short description of an input pair key ("DmolarT_INPUTS" for instance) More...

const std::string &	get_input_pair_long_desc (input_pairs pair)
	Return the long description of an input pair key ("Molar density in mol/m^3, Temperature in K" for instance) More...

void	split_input_pair (input_pairs pair, parameters &p1, parameters &p2)
	Split an input pair into parameters for the two parts that form the pair. More...

const BackendInformation &	get_backend_information ()

void	extract_backend_families (const std::string &backend_string, backend_families &f1, backend_families &f2)
	Convert a string into the enum values. More...

void	extract_backend_families_string (std::string backend_string, backend_families &f1, std::string &f2)

std::string	get_backend_string (backends backend)

FactoryOptionsParseResult	parse_factory_options (const std::string &factory_string)

CoolPropDbl	kahanSum (const std::vector< CoolPropDbl > &x)

bool	wayToSort (CoolPropDbl i, CoolPropDbl j)

double	ramp (double x)

double	Xdd (double X, double delta, double Delta, double Delta_d, double Delta_dd)

const std::string	ERR_NOT_A_TWO_PHASE_FLUID ("This is not a two-phase fluid. Please select another fluid or avoid two-phase functions.")

const std::string	ERR_NOT_A_TWO_PHASE_STATE ("This is not a two-phase state, update state with a two-phase set of inputs")

const std::string	ERR_NOT_COMPRESSIBLE ("This function is invalid for incompressible fluids.")

const std::string	ERR_NOT_A_TWO_PHASE_FUNCTION ("This function is invalid in the two-phase region.")

void	validate_json_against_schema (const std::string &instance_json, const std::string &schema_json)

std::string	to_canonical_json_str (const std::string &json_str)

std::vector< double >	NDNewtonRaphson_Jacobian (FuncWrapperND *f, const std::vector< double > &x, double tol, int maxiter, double w)

double	Newton (FuncWrapper1DWithDeriv *f, double x0, double ftol, int maxiter)

double	Halley (FuncWrapper1DWithTwoDerivs *f, double x0, double ftol, int maxiter, double xtol_rel)

double	Householder4 (FuncWrapper1DWithThreeDerivs *f, double x0, double ftol, int maxiter, double xtol_rel)

double	Secant (FuncWrapper1D *f, double x0, double dx, double tol, int maxiter)

double	BoundedSecant (FuncWrapper1D *f, double x0, double xmin, double xmax, double dx, double tol, int maxiter)

double	ExtrapolatingSecant (FuncWrapper1D *f, double x0, double dx, double tol, int maxiter)

double	Brent (FuncWrapper1D *f, double a, double b, double macheps, double t, int maxiter)

void	compare_REFPROP_and_CoolProp (const std::string &fluid, CoolProp::input_pairs inputs, double val1, double val2, std::size_t N, double d1, double d2)

void	compare_REFPROP_and_CoolProp (const std::string &fluid, int inputs, double val1, double val2, std::size_t N, double d1=0, double d2=0)

bool	match_pair (parameters key1, parameters key2, parameters x1, parameters x2, bool &swap)

bool	is_Qmass_pair (input_pairs p)
	Return true if the input pair involves a mass-based quality (Qmass). More...

template<class T >
CoolProp::input_pairs	generate_update_pair (parameters key1, const T &value1, parameters key2, const T &value2, T &out1, T &out2) noexcept
	Generate an update pair from key, value pairs. More...

std::uint64_t	fnv1a_64 (const void *data, std::size_t n) noexcept

std::uint64_t	fnv1a_64 (std::string_view s) noexcept

std::string	to_hex16 (std::uint64_t h)

template<class T >
std::size_t	num_rows (std::vector< T > const &in)
	Some shortcuts and regularly needed operations. More...

template<class T >
std::size_t	num_rows (std::vector< std::vector< T > > const &in)

template<class T >
std::size_t	max_cols (std::vector< std::vector< T > > const &in)

template<class T >
bool	is_squared (std::vector< std::vector< T > > const &in)

template<class T >
std::size_t	num_cols (std::vector< T > const &in)

template<class T >
std::size_t	num_cols (std::vector< std::vector< T > > const &in)

template<typename T >
std::vector< T >	eigen_to_vec1D (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &coefficients, int axis=0)
	Convert vectors and matrices. More...

template<class T >
std::vector< std::vector< T > >	eigen_to_vec (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &coefficients)

template<class T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	vec_to_eigen (const std::vector< std::vector< T > > &coefficients)

template<class T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	vec_to_eigen (const std::vector< T > &coefficients, int axis=0)

template<class T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	vec_to_eigen (const T &coefficient)

template<class T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	makeColVector (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix)
	Convert 1D matrix to vector. More...

template<class T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	makeVector (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix)

template<class T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	makeRowVector (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix)

template<class T >
void	removeRow (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix, std::size_t rowToRemove)
	Remove rows and columns from matrices. More...

template<class T >
void	removeColumn (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix, std::size_t colToRemove)

template<class T >
std::string	vec_to_string (const std::vector< T > &a, const char *fmt)
	Templates for turning vectors (1D-matrices) into strings. More...

template<class T >
std::string	vec_to_string (const std::vector< T > &a)

std::string	stringvec_to_string (const std::vector< std::string > &a)
	Templates for turning vectors (1D-matrices) into strings. More...

template<class T >
std::string	vec_to_string (const T &a, const char *fmt)
	Templates for turning numbers (0D-matrices) into strings. More...

template<class T >
std::string	vec_to_string (const T &a)

template<class T >
std::string	vec_to_string (const std::vector< std::vector< T > > &A, const char *fmt)
	Templates for turning 2D-matrices into strings. More...

template<class T >
std::string	vec_to_string (const std::vector< std::vector< T > > &A)

template<class T >
std::string	mat_to_string (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &A, const char *fmt)
	Templates for turning Eigen matrices into strings. More...

template<class T >
std::string	mat_to_string (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &A)

template<typename T >
void	swap_rows (std::vector< std::vector< T > > *A, size_t row1, size_t row2)
	Template class for turning numbers (0D-matrices) into strings. More...

template<typename T >
void	subtract_row_multiple (std::vector< std::vector< T > > *A, size_t row, T multiple, size_t pivot_row)

template<typename T >
void	divide_row_by (std::vector< std::vector< T > > *A, size_t row, T value)

template<typename T >
size_t	get_pivot_row (std::vector< std::vector< T > > *A, size_t col)

template<typename T >
std::vector< std::vector< T > >	linsolve_Gauss_Jordan (std::vector< std::vector< T > > const &A, std::vector< std::vector< T > > const &B)

template<class T >
std::vector< std::vector< T > >	linsolve (std::vector< std::vector< T > > const &A, std::vector< std::vector< T > > const &B)

template<class T >
std::vector< T >	linsolve (std::vector< std::vector< T > > const &A, std::vector< T > const &b)

template<class T >
std::vector< T >	get_row (std::vector< std::vector< T > > const &in, size_t row)

template<class T >
std::vector< T >	get_col (std::vector< std::vector< T > > const &in, size_t col)

template<class T >
std::vector< std::vector< T > >	make_squared (std::vector< std::vector< T > > const &in)

template<class T >
T	multiply (std::vector< T > const &a, std::vector< T > const &b)

template<class T >
std::vector< T >	multiply (std::vector< std::vector< T > > const &A, std::vector< T > const &b)

template<class T >
std::vector< std::vector< T > >	multiply (std::vector< std::vector< T > > const &A, std::vector< std::vector< T > > const &B)

template<class T >
T	dot_product (std::vector< T > const &a, std::vector< T > const &b)

template<class T >
std::vector< T >	cross_product (std::vector< T > const &a, std::vector< T > const &b)

template<class T >
std::vector< std::vector< T > >	transpose (std::vector< std::vector< T > > const &in)

template<class T >
std::vector< std::vector< T > >	invert (std::vector< std::vector< T > > const &in)

void	removeRow (Eigen::MatrixXd &matrix, unsigned int rowToRemove)

void	removeColumn (Eigen::MatrixXd &matrix, unsigned int colToRemove)

template<typename Derived >
Eigen::MatrixXd	minor_matrix (const Eigen::MatrixBase< Derived > &A, std::size_t i, std::size_t j)

double	Brent (FuncWrapper1D &f, double a, double b, double macheps, double t, int maxiter)

double	Secant (FuncWrapper1D &f, double x0, double dx, double ftol, int maxiter)

double	ExtrapolatingSecant (FuncWrapper1D &f, double x0, double dx, double ftol, int maxiter)

double	BoundedSecant (FuncWrapper1D &f, double x0, double xmin, double xmax, double dx, double ftol, int maxiter)

double	Newton (FuncWrapper1DWithDeriv &f, double x0, double ftol, int maxiter)

double	Halley (FuncWrapper1DWithTwoDerivs &f, double x0, double ftol, int maxiter, double xtol_rel=1e-12)

double	Householder4 (FuncWrapper1DWithThreeDerivs &f, double x0, double ftol, int maxiter, double xtol_rel=1e-12)

Variables
std::unique_ptr< Configuration >	pconfig

const std::vector< parameter_info >	parameter_info_list

std::unique_ptr< ParameterInformation >	parameter_information_p

const phase_info	phase_info_list []

std::unique_ptr< PhaseInformation >	phase_information_p

const scheme_info	scheme_info_list []

std::unique_ptr< SchemeInformation >	scheme_information_p

const input_pair_info	input_pair_list []

std::unique_ptr< InputPairInformation >	input_pair_information_p

const std::vector< backend_family_info >	backend_family_list

const std::vector< backend_info >	backend_list

std::unique_ptr< BackendInformation >	backend_information_p

constexpr double	CPPOLY_EPSILON = DBL_EPSILON * 100.0

constexpr double	CPPOLY_DELTA = CPPOLY_EPSILON * 10.0

Typedef Documentation

◆ AttributeError

using CoolProp::AttributeError = typedef CoolPropError<CoolPropBaseError::eAttribute>

Definition at line 54 of file Exceptions.h.

◆ CompositionError

using CoolProp::CompositionError = typedef ValueErrorSpec<CoolPropBaseError::eComposition>

Definition at line 71 of file Exceptions.h.

◆ DepartureFunctionPointer

using CoolProp::DepartureFunctionPointer = typedef shared_ptr<DepartureFunction>

Definition at line 198 of file ExcessHEFunction.h.

◆ DirectorySizeError

using CoolProp::DirectorySizeError = typedef CoolPropError<CoolPropBaseError::eDirectorySize>

Definition at line 60 of file Exceptions.h.

◆ HandleError

using CoolProp::HandleError = typedef CoolPropError<CoolPropBaseError::eHandle>

Definition at line 58 of file Exceptions.h.

◆ InputError

using CoolProp::InputError = typedef ValueErrorSpec<CoolPropBaseError::eInput>

Definition at line 72 of file Exceptions.h.

◆ KeyError

using CoolProp::KeyError = typedef CoolPropError<CoolPropBaseError::eKey>

Definition at line 57 of file Exceptions.h.

◆ mat

using CoolProp::mat = typedef std::vector<std::vector<double> >

This class implements bicubic interpolation, as very clearly laid out by the page on wikipedia: http://en.wikipedia.org/wiki/Bicubic_interpolation.

Essentially you have an already-inverted matrix that you need to multiply

\[ A^{-1} = \left[ \begin{array}{*{16}c} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ -3 & 3 & 0 & 0 & -2 & -1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 2 & -2 & 0 & 0 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & -3 & 3 & 0 & 0 & -2 & -1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 2 & -2 & 0 & 0 & 1 & 1 & 0 & 0 \\ -3 & 0 & 3 & 0 & 0 & 0 & 0 & 0 & -2 & 0 & -1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & -3 & 0 & 3 & 0 & 0 & 0 & 0 & 0 & -2 & 0 & -1 & 0 \\ 9 & -9 & -9 & 9 & 6 & 3 & -6 & -3 & 6 & -6 & 3 & -3 & 4 & 2 & 2 & 1 \\ -6 & 6 & 6 & -6 & -3 & -3 & 3 & 3 & -4 & 4 & -2 & 2 & -2 & -2 & -1 & -1 \\ 2 & 0 & -2 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 2 & 0 & -2 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \\ -6 & 6 & 6 & -6 & -4 & -2 & 4 & 2 & -3 & 3 & -3 & 3 & -2 & -1 & -2 & -1 \\ 4 & -4 & -4 & 4 & 2 & 2 & -2 & -2 & 2 & -2 & 2 & -2 & 1 & 1 & 1 & 1 \end{array} \right] \]

\[ x = \frac{h-h_i}{h_{i+1}-h_i} \]

\[ \frac{\partial x}{\partial h} = \frac{1}{h_{i+1}-h_i} \]

\[ \frac{\partial h}{\partial x} = h_{i+1}-h_i \]

\[ y = \frac{p-p_j}{p_{j+1}-p_j} \]

\[ \frac{\partial y}{\partial p} = \frac{1}{p_{j+1}-p_j} \]

\[ \frac{\partial p}{\partial y} = p_{j+1}-p_j \]

\[ \frac{\partial f}{\partial x} = \frac{\partial f}{\partial h}\cdot\frac{\partial h}{\partial x} \]

\

Definition at line 62 of file BicubicBackend.h.

◆ MultipleSolutionsError

using CoolProp::MultipleSolutionsError = typedef ValueErrorSpec<CoolPropBaseError::eMultipleSolutions>

Thrown when a saturation flash input maps to more than one temperature on the saturation curve (e.g. water saturated-vapor enthalpy at a given h has two T-roots). The caller should use update_with_guesses with a guess.T to pick a branch. See GitHub #2773.

Definition at line 78 of file Exceptions.h.

◆ NotAvailableError

using CoolProp::NotAvailableError = typedef ValueErrorSpec<CoolPropBaseError::eNotAvailable>

Definition at line 73 of file Exceptions.h.

◆ NotImplementedError

using CoolProp::NotImplementedError = typedef CoolPropError<CoolPropBaseError::eNotImplemented>

Definition at line 52 of file Exceptions.h.

◆ OutOfRangeError

using CoolProp::OutOfRangeError = typedef CoolPropError<CoolPropBaseError::eOutOfRange>

Definition at line 55 of file Exceptions.h.

◆ SolutionError

using CoolProp::SolutionError = typedef CoolPropError<CoolPropBaseError::eSolution>

Definition at line 53 of file Exceptions.h.

◆ STLMatrix

typedef std::vector< std::vector< CoolPropDbl > > CoolProp::STLMatrix

Definition at line 13 of file ExcessHEFunction.h.

◆ UnableToLoadError

using CoolProp::UnableToLoadError = typedef CoolPropError<CoolPropBaseError::eUnableToLoad>

Definition at line 59 of file Exceptions.h.

◆ ValueError

using CoolProp::ValueError = typedef CoolPropError<CoolPropBaseError::eValue>

Definition at line 56 of file Exceptions.h.

◆ WrongFluidError

using CoolProp::WrongFluidError = typedef ValueErrorSpec<CoolPropBaseError::eWrongFluid>

Definition at line 70 of file Exceptions.h.

Enumeration Type Documentation

◆ backend_families

enum CoolProp::backend_families : int

The structure is taken directly from the AbstractState class.

Enumerator
INVALID_BACKEND_FAMILY
HEOS_BACKEND_FAMILY
REFPROP_BACKEND_FAMILY
INCOMP_BACKEND_FAMILY
IF97_BACKEND_FAMILY
TREND_BACKEND_FAMILY
TTSE_BACKEND_FAMILY
BICUBIC_BACKEND_FAMILY
SRK_BACKEND_FAMILY
PR_BACKEND_FAMILY
VTPR_BACKEND_FAMILY
PCSAFT_BACKEND_FAMILY
SVDSBTL_BACKEND_FAMILY

Definition at line 493 of file DataStructures.h.

◆ backends

enum CoolProp::backends : int

Enumerator
INVALID_BACKEND
HEOS_BACKEND_PURE
HEOS_BACKEND_MIX
REFPROP_BACKEND_PURE
REFPROP_BACKEND_MIX
INCOMP_BACKEND
IF97_BACKEND
TREND_BACKEND
TTSE_BACKEND
BICUBIC_BACKEND
SRK_BACKEND
PR_BACKEND
VTPR_BACKEND
PCSAFT_BACKEND
SVDSBTL_BACKEND

Definition at line 509 of file DataStructures.h.

◆ composition_types

enum CoolProp::composition_types

These are constants for the compositions.

Enumerator
IFRAC_MASS
IFRAC_MOLE
IFRAC_VOLUME
IFRAC_UNDEFINED
IFRAC_PURE

Definition at line 270 of file DataStructures.h.

◆ fast_evaluate_status

enum CoolProp::fast_evaluate_status : int

Per-point status codes for AbstractState::fast_evaluate. Zero means success.

Enumerator
fast_evaluate_ok
fast_evaluate_out_of_range
fast_evaluate_two_phase_disallowed
fast_evaluate_unsupported_input
fast_evaluate_unsupported_output
fast_evaluate_internal_error

Definition at line 197 of file DataStructures.h.

◆ fluid_types

enum CoolProp::fluid_types

These are unit types for the fluid.

Enumerator
FLUID_TYPE_PURE
FLUID_TYPE_PSEUDOPURE
FLUID_TYPE_REFPROP
FLUID_TYPE_INCOMPRESSIBLE_LIQUID
FLUID_TYPE_INCOMPRESSIBLE_SOLUTION
FLUID_TYPE_UNDEFINED

Definition at line 280 of file DataStructures.h.

◆ input_pairs

enum CoolProp::input_pairs : int

These are input pairs that can be used for the update function (in each pair, input keys are sorted alphabetically)

Enumerator
INPUT_PAIR_INVALID
QT_INPUTS	Molar quality, Temperature in K.
QmassT_INPUTS	Mass-basis quality, Temperature in K.
PQ_INPUTS	Pressure in Pa, Molar quality.
PQmass_INPUTS	Pressure in Pa, Mass-basis quality.
QSmolar_INPUTS	Molar quality, Entropy in J/mol/K.
QmassSmolar_INPUTS	Mass-basis quality, Entropy in J/mol/K.
QSmass_INPUTS	Molar quality, Entropy in J/kg/K.
QmassSmass_INPUTS	Mass-basis quality, Entropy in J/kg/K.
HmolarQ_INPUTS	Enthalpy in J/mol, Molar quality.
HmolarQmass_INPUTS	Enthalpy in J/mol, Mass-basis quality.
HmassQ_INPUTS	Enthalpy in J/kg, Molar quality.
HmassQmass_INPUTS	Enthalpy in J/kg, Mass-basis quality.
DmolarQ_INPUTS	Density in mol/m^3, Molar quality.
DmolarQmass_INPUTS	Density in mol/m^3, Mass-basis quality.
DmassQ_INPUTS	Density in kg/m^3, Molar quality.
DmassQmass_INPUTS	Density in kg/m^3, Mass-basis quality.
PT_INPUTS	Pressure in Pa, Temperature in K.
DmassT_INPUTS	Mass density in kg/m^3, Temperature in K.
DmolarT_INPUTS	Molar density in mol/m^3, Temperature in K.
HmolarT_INPUTS	Enthalpy in J/mol, Temperature in K.
HmassT_INPUTS	Enthalpy in J/kg, Temperature in K.
SmolarT_INPUTS	Entropy in J/mol/K, Temperature in K.
SmassT_INPUTS	Entropy in J/kg/K, Temperature in K.
TUmolar_INPUTS	Temperature in K, Internal energy in J/mol.
TUmass_INPUTS	Temperature in K, Internal energy in J/kg.
DmassP_INPUTS	Mass density in kg/m^3, Pressure in Pa.
DmolarP_INPUTS	Molar density in mol/m^3, Pressure in Pa.
HmassP_INPUTS	Enthalpy in J/kg, Pressure in Pa.
HmolarP_INPUTS	Enthalpy in J/mol, Pressure in Pa.
PSmass_INPUTS	Pressure in Pa, Entropy in J/kg/K.
PSmolar_INPUTS	Pressure in Pa, Entropy in J/mol/K.
PUmass_INPUTS	Pressure in Pa, Internal energy in J/kg.
PUmolar_INPUTS	Pressure in Pa, Internal energy in J/mol.
HmassSmass_INPUTS	Enthalpy in J/kg, Entropy in J/kg/K.
HmolarSmolar_INPUTS	Enthalpy in J/mol, Entropy in J/mol/K.
SmassUmass_INPUTS	Entropy in J/kg/K, Internal energy in J/kg.
SmolarUmolar_INPUTS	Entropy in J/mol/K, Internal energy in J/mol.
DmassHmass_INPUTS	Mass density in kg/m^3, Enthalpy in J/kg.
DmolarHmolar_INPUTS	Molar density in mol/m^3, Enthalpy in J/mol.
DmassSmass_INPUTS	Mass density in kg/m^3, Entropy in J/kg/K.
DmolarSmolar_INPUTS	Molar density in mol/m^3, Entropy in J/mol/K.
DmassUmass_INPUTS	Mass density in kg/m^3, Internal energy in J/kg.
DmolarUmolar_INPUTS	Molar density in mol/m^3, Internal energy in J/mol.

Definition at line 292 of file DataStructures.h.

◆ parameters

enum CoolProp::parameters : int

Define some constants that will be used throughout

These are constants for the input and output parameters The structure is taken directly from the AbstractState class.

Enumerator
INVALID_PARAMETER
igas_constant	Ideal-gas constant.
imolar_mass	Molar mass.
iacentric_factor	Acentric factor.
irhomolar_reducing	Molar density used for the reducing state.
irhomolar_critical	Molar density used for the critical point.
iT_reducing	Temperature at the reducing state.
iT_critical	Temperature at the critical point.
irhomass_reducing	Mass density at the reducing state.
irhomass_critical	Mass density at the critical point.
iP_critical	Pressure at the critical point.
iP_reducing	Pressure at the reducing point.
iT_triple	Triple point temperature.
iP_triple	Triple point pressure.
iT_min	Minimum temperature.
iT_max	Maximum temperature.
iP_max	Maximum pressure.
iP_min	Minimum pressure.
idipole_moment	Dipole moment.
iT	Temperature.
iP	Pressure.
iQ	Vapor quality (molar; alias for iQmolar in this codebase)
iQmass	Mass-basis vapor quality.
iTau	Reciprocal reduced temperature.
iDelta	Reduced density.
iDmolar	Mole-based density.
iHmolar	Mole-based enthalpy.
iSmolar	Mole-based entropy.
iCpmolar	Mole-based constant-pressure specific heat.
iCp0molar	Mole-based ideal-gas constant-pressure specific heat.
iCvmolar	Mole-based constant-volume specific heat.
iUmolar	Mole-based internal energy.
iGmolar	Mole-based Gibbs energy.
iHelmholtzmolar	Mole-based Helmholtz energy.
iHmolar_residual	The residual molar enthalpy.
iSmolar_residual	The residual molar entropy (as a function of temperature and density)
iGmolar_residual	The residual molar Gibbs energy.
iHmolar_idealgas	The ideal gas molar enthalpy.
iSmolar_idealgas	The ideal gas molar entropy.
iUmolar_idealgas	The ideal gas molar internal energy.
iDmass	Mass-based density.
iHmass	Mass-based enthalpy.
iSmass	Mass-based entropy.
iCpmass	Mass-based constant-pressure specific heat.
iCp0mass	Mass-based ideal-gas specific heat.
iCvmass	Mass-based constant-volume specific heat.
iUmass	Mass-based internal energy.
iGmass	Mass-based Gibbs energy.
iHelmholtzmass	Mass-based Helmholtz energy.
iHmass_idealgas	The ideal gas specific enthalpy.
iSmass_idealgas	The ideal gas specific entropy.
iUmass_idealgas	The ideal gas specific internal energy.
iviscosity	Viscosity.
iconductivity	Thermal conductivity.
isurface_tension	Surface tension.
iPrandtl	The Prandtl number.
ispeed_sound	Speed of sound.
iisothermal_compressibility	Isothermal compressibility.
iisobaric_expansion_coefficient	Isobaric expansion coefficient.
iisentropic_expansion_coefficient	Isentropic expansion coefficient.
ifundamental_derivative_of_gas_dynamics	The fundamental derivative of gas dynamics.
ialphar
idalphar_dtau_constdelta
idalphar_ddelta_consttau
ialpha0
idalpha0_dtau_constdelta
idalpha0_ddelta_consttau
id2alpha0_ddelta2_consttau
id3alpha0_ddelta3_consttau
iBvirial	Second virial coefficient.
iCvirial	Third virial coefficient.
idBvirial_dT	Derivative of second virial coefficient with temperature.
idCvirial_dT	Derivative of third virial coefficient with temperature.
iZ	The compressibility factor Z = pv/(RT)
iPIP	The phase identification parameter of Venkatarathnam and Oellrich.
ifraction_min	The minimum fraction (mole, mass, volume) for incompressibles.
ifraction_max	The maximum fraction (mole,mass,volume) for incompressibles.
iT_freeze	The freezing temperature for incompressibles.
iGWP20	The 20-year global warming potential.
iGWP100	The 100-year global warming potential.
iGWP500	The 500-year global warming potential.
iFH	Fire hazard index.
iHH	Health hazard index.
iPH	Physical hazard index.
iODP	Ozone depletion potential (R-11 = 1.0)
iPhase	The phase index of the given state.
iundefined_parameter	The last parameter, so we can check that all parameters are described in DataStructures.cpp.

Definition at line 64 of file DataStructures.h.

◆ phases

enum CoolProp::phases : int

These are constants for the phases of the fluid.

Enumerator
iphase_liquid	Subcritical liquid.
iphase_supercritical	Supercritical (p > pc, T > Tc)
iphase_supercritical_gas	Supercritical gas (p < pc, T > Tc)
iphase_supercritical_liquid	Supercritical liquid (p > pc, T < Tc)
iphase_critical_point	At the critical point.
iphase_gas	Subcritical gas.
iphase_twophase	Twophase.
iphase_unknown	Unknown phase.
iphase_not_imposed

Definition at line 183 of file DataStructures.h.

◆ schemes

enum CoolProp::schemes

Constants for the different PC-SAFT association schemes (see Huang and Radosz 1990)

Enumerator
i1
i2a
i2b
i3a
i3b
i4a
i4b
i4c

Definition at line 208 of file DataStructures.h.

◆ x_N_dependency_flag

enum CoolProp::x_N_dependency_flag

Enumerator
XN_INDEPENDENT	x_N is an independent variable, and not calculated by \( x_N = 1-\sum_i x_i\)
XN_DEPENDENT	x_N is an dependent variable, calculated by \( x_N = 1-\sum_i x_i\)

Definition at line 19 of file ReducingFunctions.h.

Function Documentation

◆ _get_config()

Configuration * CoolProp::_get_config ( )

A helper function to ensure that configuration is not accessed before it is initialized (was formerly static)

Definition at line 128 of file Configuration.cpp.

◆ _PropsSI_initialize()

void CoolProp::_PropsSI_initialize	(	const std::string &	backend,
		const std::vector< std::string > &	fluid_names,
		const std::vector< double > &	z,
		shared_ptr< AbstractState > &	State
	)

Definition at line 241 of file CoolProp.cpp.

◆ _PropsSI_outputs()

void CoolProp::_PropsSI_outputs	(	shared_ptr< AbstractState > &	State,
		const std::vector< output_parameter > &	output_parameters,
		CoolProp::input_pairs	input_pair,
		const std::vector< double > &	in1,
		const std::vector< double > &	in2,
		std::vector< std::vector< double > > &	IO
	)

Definition at line 343 of file CoolProp.cpp.

◆ _PropsSImulti()

void CoolProp::_PropsSImulti	(	const std::vector< std::string > &	Outputs,
		const std::string &	Name1,
		const std::vector< double > &	Prop1,
		const std::string &	Name2,
		const std::vector< double > &	Prop2,
		const std::string &	backend,
		const std::vector< std::string > &	fluids,
		const std::vector< double > &	fractions,
		std::vector< std::vector< double > > &	IO
	)

Definition at line 576 of file CoolProp.cpp.

◆ add_fluids_as_JSON()

bool CoolProp::add_fluids_as_JSON	(	const std::string &	backend,
		const std::string &	fluidstring
	)

Add fluids as a JSON-formatted string.

Parameters

backend	The backend to which these should be added; e.g. "HEOS", "SRK", "PR"
fluidstring	The JSON-formatted string containing the fluid data

Returns: output Returns true if the fluids were able to be added

Definition at line 703 of file CoolProp.cpp.

◆ apply_simple_mixing_rule()

void CoolProp::apply_simple_mixing_rule	(	const std::string &	identifier1,
		const std::string &	identifier2,
		const std::string &	rule
	)

Add a simple mixing rule.

Apply a simple mixing rule for a given binary pair.

Parameters

identifier1	The CAS # (or name) for the first fluid
identifier2	The CAS # (or name) for the second fluid
rule	The simple mixing rule to be used ("linear", "Lorentz-Berthelot")

Definition at line 286 of file MixtureParameters.cpp.

◆ BoundedSecant() [1/2]

double CoolProp::BoundedSecant	(	FuncWrapper1D &	f,
		double	x0,
		double	xmin,
		double	xmax,
		double	dx,
		double	ftol,
		int	maxiter
	)

inline

Definition at line 93 of file Solvers.h.

◆ BoundedSecant() [2/2]

double CoolProp::BoundedSecant	(	FuncWrapper1D *	f,
		double	x0,
		double	xmin,
		double	xmax,
		double	dx,
		double	tol,
		int	maxiter
	)

In the secant function, a 1-D Newton-Raphson solver is implemented. An initial guess for the solution is provided.

Parameters

f	A pointer to an instance of the FuncWrapper1D class that implements the call() function
x0	The initial guess for the solution
xmax	The upper bound for the solution
xmin	The lower bound for the solution
dx	The initial amount that is added to x in order to build the numerical derivative
tol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 373 of file Solvers.cpp.

◆ Brent() [1/2]

double CoolProp::Brent	(	FuncWrapper1D &	f,
		double	a,
		double	b,
		double	macheps,
		double	t,
		int	maxiter
	)

inline

Definition at line 83 of file Solvers.h.

◆ Brent() [2/2]

double CoolProp::Brent	(	FuncWrapper1D *	f,
		double	a,
		double	b,
		double	macheps,
		double	t,
		int	maxiter
	)

This function implements a 1-D bounded solver using the algorithm from Brent, R. P., Algorithms for Minimization Without Derivatives. Englewood Cliffs, NJ: Prentice-Hall, 1973. Ch. 3-4.

a and b must bound the solution of interest and f(a) and f(b) must have opposite signs. If the function is continuous, there must be at least one solution in the interval [a,b].

Parameters

f	A pointer to an instance of the FuncWrapper1D class that must implement the class() function
a	The minimum bound for the solution of f=0
b	The maximum bound for the solution of f=0
macheps	The machine precision
t	Tolerance (absolute)
maxiter	Maximum number of steps allowed. Will throw a SolutionError if the solution cannot be found

Definition at line 522 of file Solvers.cpp.

◆ compare_REFPROP_and_CoolProp() [1/2]

void CoolProp::compare_REFPROP_and_CoolProp	(	const std::string &	fluid,
		CoolProp::input_pairs	inputs,
		double	val1,
		double	val2,
		std::size_t	N,
		double	d1,
		double	d2
	)

Definition at line 16 of file SpeedTest.cpp.

◆ compare_REFPROP_and_CoolProp() [2/2]

void CoolProp::compare_REFPROP_and_CoolProp	(	const std::string &	fluid,
		int	inputs,
		double	val1,
		double	val2,
		std::size_t	N,
		double	d1 = `0`,
		double	d2 = `0`
	)

◆ config_key_description() [1/2]

std::string CoolProp::config_key_description ( configuration_keys keys )

Return a string description of the configuration key.

Definition at line 80 of file Configuration.cpp.

◆ config_key_description() [2/2]

std::string CoolProp::config_key_description ( const std::string & key )

Return a string description of the configuration key (with the key passed as a string)

Definition at line 96 of file Configuration.cpp.

◆ config_key_to_string()

std::string CoolProp::config_key_to_string ( configuration_keys keys )

Convert the configuration key to a string in a 1-1 representation.

Definition at line 64 of file Configuration.cpp.

◆ config_string_to_key()

configuration_keys CoolProp::config_string_to_key ( const std::string & s )

Go from string to enum key.

Convert a string description to a configuration key.

Definition at line 111 of file Configuration.cpp.

◆ cross_product()

template<class T >

std::vector< T > CoolProp::cross_product	(	std::vector< T > const &	a,
		std::vector< T > const &	b
	)

Definition at line 843 of file MatrixMath.h.

◆ divide_row_by()

template<typename T >

void CoolProp::divide_row_by	(	std::vector< std::vector< T > > *	A,
		size_t	row,
		T	value
	)

Definition at line 571 of file MatrixMath.h.

◆ dot_product()

template<class T >

T CoolProp::dot_product	(	std::vector< T > const &	a,
		std::vector< T > const &	b
	)

Definition at line 835 of file MatrixMath.h.

◆ eigen_to_vec()

template<class T >

std::vector< std::vector< T > > CoolProp::eigen_to_vec ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & coefficients )

Parameters

coefficients matrix containing the ordered coefficients

Definition at line 119 of file MatrixMath.h.

◆ eigen_to_vec1D()

template<typename T >

std::vector< T > CoolProp::eigen_to_vec1D	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	coefficients,
		int	axis = `0`
	)

Convert vectors and matrices.

Conversion functions for the different kinds of object-like parameters. This might be obsolete at a later stage, but now it is still needed.

Parameters

coefficients	matrix containing the ordered coefficients
axis	axis along which to extract

Definition at line 97 of file MatrixMath.h.

◆ ERR_NOT_A_TWO_PHASE_FLUID()

const std::string CoolProp::ERR_NOT_A_TWO_PHASE_FLUID ( "This is not a two-phase fluid. Please select another fluid or avoid two-phase functions." )

◆ ERR_NOT_A_TWO_PHASE_FUNCTION()

const std::string CoolProp::ERR_NOT_A_TWO_PHASE_FUNCTION ( "This function is invalid in the two-phase region." )

◆ ERR_NOT_A_TWO_PHASE_STATE()

const std::string CoolProp::ERR_NOT_A_TWO_PHASE_STATE	(	"This is not a two-phase	state,
		update state with a two-phase set of inputs"
	)

◆ ERR_NOT_COMPRESSIBLE()

const std::string CoolProp::ERR_NOT_COMPRESSIBLE ( "This function is invalid for incompressible fluids." )

◆ extract_backend()

void CoolProp::extract_backend	(	std::string	fluid_string,
		std::string &	backend,
		std::string &	fluid
	)

Extract the backend from a string - something like "HEOS::Water" would split to "HEOS" and "Water". If no backend is specified, the backend will be set to "?".

Parameters

fluid_string	The input string
backend	The output backend, if none found, "?"
fluid	The output fluid string (minus the backend string)

Definition at line 113 of file CoolProp.cpp.

◆ extract_backend_families()

void CoolProp::extract_backend_families	(	const std::string &	backend_string,
		backend_families &	f1,
		backend_families &	f2
	)

Convert a string into the enum values.

Definition at line 855 of file DataStructures.cpp.

◆ extract_backend_families_string()

void CoolProp::extract_backend_families_string	(	std::string	backend_string,
		backend_families &	f1,
		std::string &	f2
	)

Definition at line 872 of file DataStructures.cpp.

◆ extract_fractions()

std::string CoolProp::extract_fractions	(	const std::string &	fluid_string,
		std::vector< double > &	fractions
	)

Extract fractions (molar, mass, etc.) encoded in the string if any.

Parameters

fluid_string	The input string
fractions	The fractions

Returns: The fluids, as a '&' delimited string

Definition at line 154 of file CoolProp.cpp.

◆ ExtrapolatingSecant() [1/2]

double CoolProp::ExtrapolatingSecant	(	FuncWrapper1D &	f,
		double	x0,
		double	dx,
		double	ftol,
		int	maxiter
	)

inline

Definition at line 90 of file Solvers.h.

◆ ExtrapolatingSecant() [2/2]

double CoolProp::ExtrapolatingSecant	(	FuncWrapper1D *	f,
		double	x0,
		double	dx,
		double	tol,
		int	maxiter
	)

In the secant function, a 1-D Newton-Raphson solver is implemented. An initial guess for the solution is provided. Note that this is different than the Secant function because if something goes out of bounds, it will just make its best guess.

Parameters

f	A pointer to an instance of the FuncWrapper1D class that implements the call() function
x0	The initial guess for the solutionh
dx	The initial amount that is added to x in order to build the numerical derivative
tol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 429 of file Solvers.cpp.

◆ fnv1a_64() [1/2]

std::uint64_t CoolProp::fnv1a_64	(	const void *	data,
		std::size_t	n
	)

inlinenoexcept

Definition at line 24 of file Hash.h.

◆ fnv1a_64() [2/2]

std::uint64_t CoolProp::fnv1a_64 ( std::string_view s )

inlinenoexcept

Definition at line 36 of file Hash.h.

◆ force_load_REFPROP()

bool CoolProp::force_load_REFPROP ( )

Definition at line 2788 of file REFPROPMixtureBackend.cpp.

◆ force_unload_REFPROP()

bool CoolProp::force_unload_REFPROP ( )

Definition at line 2801 of file REFPROPMixtureBackend.cpp.

◆ generate_update_pair()

template<class T >

CoolProp::input_pairs CoolProp::generate_update_pair	(	parameters	key1,
		const T &	value1,
		parameters	key2,
		const T &	value2,
		T &	out1,
		T &	out2
	)

noexcept

Generate an update pair from key, value pairs.

If the input pair is valid, v1 and v2 will correspond to the returned output pair

Parameters

key1	The first input key
value1	The first input value
key2	The second input key
value2	The second input value
out1	The first output value
out2	The second output value

Returns: pair, or INPUT_PAIR_INVALID if not valid

< Molar quality, Temperature in K

< Mass-basis quality, Temperature in K

< Pressure in Pa, Molar quality

< Pressure in Pa, Mass-basis quality

< Pressure in Pa, Temperature in K

< Entropy in J/kg/K, Internal energy in J/kg

< Entropy in J/mol/K, Internal energy in J/mol

Definition at line 381 of file DataStructures.h.

◆ get_backend_information()

const BackendInformation & CoolProp::get_backend_information ( )

Definition at line 847 of file DataStructures.cpp.

◆ get_backend_library()

BackendLibrary & CoolProp::get_backend_library ( )

inline

Definition at line 55 of file AbstractState.cpp.

◆ get_backend_string()

std::string CoolProp::get_backend_string ( backends backend )

Definition at line 884 of file DataStructures.cpp.

◆ get_col()

template<class T >

std::vector< T > CoolProp::get_col	(	std::vector< std::vector< T > > const &	in,
		size_t	col
	)

Definition at line 743 of file MatrixMath.h.

◆ get_config_as_json_string()

std::string CoolProp::get_config_as_json_string ( )

Get all the values in the configuration as a json-formatted string.

Definition at line 163 of file Configuration.cpp.

◆ get_config_bool()

bool CoolProp::get_config_bool ( configuration_keys key )

Return the value of a boolean key from the configuration.

GETTERS

Definition at line 151 of file Configuration.cpp.

◆ get_config_double()

double CoolProp::get_config_double ( configuration_keys key )

Return the value of a double configuration key.

Definition at line 157 of file Configuration.cpp.

◆ get_config_int()

int CoolProp::get_config_int ( configuration_keys key )

Return the value of an integer key from the configuration.

Definition at line 154 of file Configuration.cpp.

◆ get_config_string()

std::string CoolProp::get_config_string ( configuration_keys key )

Return the value of a string configuration key.

Definition at line 160 of file Configuration.cpp.

◆ get_csv_mixture_binary_pairs()

std::string CoolProp::get_csv_mixture_binary_pairs ( )

Get a comma-separated list of CAS code pairs.

Each of the pairs will be CAS1&CAS2 ("&" delimited)

Definition at line 291 of file MixtureParameters.cpp.

◆ get_csv_parameter_list()

std::string CoolProp::get_csv_parameter_list ( )

Return a list of parameters.

Get a comma separated list of parameters.

Definition at line 204 of file DataStructures.cpp.

◆ get_csv_predefined_mixtures()

std::string CoolProp::get_csv_predefined_mixtures ( )

Get a comma-separated list of predefined mixtures in CoolProp.

Definition at line 53 of file MixtureParameters.cpp.

◆ get_debug_level()

int CoolProp::get_debug_level ( )

Get the debug level

Returns: level The level of the verbosity for the debugging output (0-10) 0: no debgging output

Definition at line 90 of file CoolProp.cpp.

◆ get_departure_function()

DepartureFunction * CoolProp::get_departure_function ( const std::string & Name )

Get the allocated Departure function for a given departure function name.

Parameters

Name	The name of the function to be used, or its alias

Warning: The pointer points to an instance created with new, you should manage the pointer with shared_ptr or similar

Definition at line 513 of file MixtureParameters.cpp.

◆ get_dT_drho() [1/2]

void CoolProp::get_dT_drho	(	AbstractState &	AS,
		parameters	index,
		CoolPropDbl &	dT,
		CoolPropDbl &	drho
	)

Definition at line 981 of file AbstractState.cpp.

◆ get_dT_drho() [2/2]

void CoolProp::get_dT_drho	(	HelmholtzEOSMixtureBackend *	HEOS,
		parameters	index,
		CoolPropDbl &	dT,
		CoolPropDbl &	drho
	)

Definition at line 2565 of file HelmholtzEOSMixtureBackend.cpp.

◆ get_dT_drho_second_derivatives()

void CoolProp::get_dT_drho_second_derivatives	(	AbstractState &	AS,
		int	index,
		CoolPropDbl &	dT2,
		CoolPropDbl &	drho_dT,
		CoolPropDbl &	drho2
	)

Definition at line 1152 of file AbstractState.cpp.

◆ get_fluid()

CoolPropFluid CoolProp::get_fluid ( const std::string & fluid_string )

Get the fluid structure.

Definition at line 376 of file FluidLibrary.cpp.

◆ get_fluid_as_JSONstring()

std::string CoolProp::get_fluid_as_JSONstring ( const std::string & identifier )

Get the fluid as a JSON string, suitable for modification and reloading.

Definition at line 381 of file FluidLibrary.cpp.

◆ get_fluid_list()

std::string CoolProp::get_fluid_list ( )

Get a comma-separated-list of fluids that are included.

Definition at line 386 of file FluidLibrary.cpp.

◆ get_fluid_param_string()

std::string CoolProp::get_fluid_param_string	(	const std::string &	FluidName,
		const std::string &	ParamName
	)

Get a string for a value from a fluid (numerical values for the fluid can be obtained from Props1SI function)

Parameters

FluidName	The name of the fluid that is part of CoolProp, for instance "n-Propane"
ParamName	A string, can be in one of the terms described in the following table

ParamName	Description
"aliases"	A comma separated list of aliases for the fluid
"CAS", "CAS_number"	The CAS number
"ASHRAE34"	The ASHRAE standard 34 safety rating
"REFPROPName","REFPROP_name"	The name of the fluid used in REFPROP
"Bibtex-XXX"	A BibTeX key, where XXX is one of the bibtex keys used in get_BibTeXKey
"pure"	"true" if the fluid is pure, "false" otherwise
"formula"	The chemical formula of the fluid in LaTeX form if available, "" otherwise

Returns: The string, or an error message if not valid input

Definition at line 1134 of file CoolProp.cpp.

◆ get_global_param_string()

std::string CoolProp::get_global_param_string ( const std::string & ParamName )

Get a globally-defined string

Parameters

ParamName A string, one of "version", "errstring", "warnstring", "gitrevision", "FluidsList", "fluids_list", "parameter_list","predefined_mixtures"

Returns: str The string, or an error message if not valid input

Definition at line 1042 of file CoolProp.cpp.

◆ get_Henrys_coeffs_FP()

void CoolProp::get_Henrys_coeffs_FP	(	const std::string &	CAS,
		double &	A,
		double &	B,
		double &	C,
		double &	Tmin,
		double &	Tmax
	)

Definition at line 1053 of file FlashRoutines.cpp.

◆ get_incompressible_fluid()

IncompressibleFluid & CoolProp::get_incompressible_fluid ( const std::string & fluid_string )

Get the fluid structure returned as a reference.

Definition at line 569 of file IncompressibleLibrary.cpp.

◆ get_incompressible_library()

JSONIncompressibleLibrary & CoolProp::get_incompressible_library ( )

Get a reference to the library instance.

Definition at line 564 of file IncompressibleLibrary.cpp.

◆ get_incompressible_list_pure()

std::string CoolProp::get_incompressible_list_pure ( )

Return a comma-separated list of incompressible pure fluid names.

Definition at line 574 of file IncompressibleLibrary.cpp.

◆ get_incompressible_list_solution()

std::string CoolProp::get_incompressible_list_solution ( )

Return a comma-separated list of solution names.

Definition at line 578 of file IncompressibleLibrary.cpp.

◆ get_input_pair_index()

input_pairs CoolProp::get_input_pair_index ( const std::string & input_pair_name )

Get the input pair index associated with its string representation.

Definition at line 585 of file DataStructures.cpp.

◆ get_input_pair_information()

const InputPairInformation & CoolProp::get_input_pair_information ( )

Definition at line 578 of file DataStructures.cpp.

◆ get_input_pair_long_desc()

const std::string & CoolProp::get_input_pair_long_desc ( input_pairs pair )

Return the long description of an input pair key ("Molar density in mol/m^3, Temperature in K" for instance)

Definition at line 602 of file DataStructures.cpp.

◆ get_input_pair_short_desc()

const std::string & CoolProp::get_input_pair_short_desc ( input_pairs pair )

Return the short description of an input pair key ("DmolarT_INPUTS" for instance)

Definition at line 594 of file DataStructures.cpp.

◆ get_library()

JSONFluidLibrary & CoolProp::get_library ( )

Get a reference to the library instance.

Definition at line 371 of file FluidLibrary.cpp.

◆ get_melting_caloric_cached()

std::shared_ptr< MeltingCaloric > CoolProp::get_melting_caloric_cached ( HelmholtzEOSMixtureBackend & H )

Return a process-global, lazily-built MeltingCaloric for H's (pure) fluid. Returns nullptr if the fluid is not pure or has no melting line. Built once per fluid name; subsequent calls return the cached instance.

Definition at line 247 of file MeltingCaloric.cpp.

◆ get_mixture_binary_pair_data()

std::string CoolProp::get_mixture_binary_pair_data	(	const std::string &	CAS1,
		const std::string &	CAS2,
		const std::string &	key
	)

Get a string for the given binary pair.

Definition at line 300 of file MixtureParameters.cpp.

◆ get_mixture_binary_pair_pcsaft()

std::string CoolProp::get_mixture_binary_pair_pcsaft	(	const std::string &	CAS1,
		const std::string &	CAS2,
		const std::string &	key
	)

Definition at line 17 of file PCSAFTLibrary.cpp.

◆ get_parameter_index()

parameters CoolProp::get_parameter_index ( const std::string & param_name )

Return the enum key corresponding to the parameter name ("Dmolar" for instance)

Definition at line 495 of file DataStructures.cpp.

◆ get_parameter_information() [1/2]

const ParameterInformation & CoolProp::get_parameter_information ( )

Definition at line 164 of file DataStructures.cpp.

◆ get_parameter_information() [2/2]

std::string CoolProp::get_parameter_information	(	int	key,
		std::string_view	info
	)

Return information about the parameter

Parameters

key	The key, one of iT, iP, etc.
info	The thing you want, one of "IO" ("IO" if input/output, "O" if output only), "short" (very short description), "long" (a longer description), "units"

Definition at line 180 of file DataStructures.cpp.

◆ get_phase_index()

phases CoolProp::get_phase_index ( const std::string & param_name )

Return the enum key corresponding to the phase name ("phase_liquid" for instance)

Definition at line 423 of file DataStructures.cpp.

◆ get_phase_information()

const PhaseInformation & CoolProp::get_phase_information ( )

Definition at line 394 of file DataStructures.cpp.

◆ get_phase_short_desc()

const std::string & CoolProp::get_phase_short_desc ( phases phase )

Definition at line 401 of file DataStructures.cpp.

◆ get_pivot_row()

template<typename T >

size_t CoolProp::get_pivot_row	(	std::vector< std::vector< T > > *	A,
		size_t	col
	)

Definition at line 578 of file MatrixMath.h.

◆ get_reducing_function_name()

std::string CoolProp::get_reducing_function_name	(	const std::string &	CAS1,
		const std::string &	CAS2
	)

Definition at line 380 of file MixtureParameters.cpp.

◆ get_row()

template<class T >

std::vector< T > CoolProp::get_row	(	std::vector< std::vector< T > > const &	in,
		size_t	row
	)

Definition at line 739 of file MatrixMath.h.

◆ get_scheme_index()

schemes CoolProp::get_scheme_index ( const std::string & scheme_name )

Return the enum key corresponding to the association scheme name ("2B" for instance)

Definition at line 486 of file DataStructures.cpp.

◆ get_scheme_information()

const SchemeInformation & CoolProp::get_scheme_information ( )

Definition at line 457 of file DataStructures.cpp.

◆ get_scheme_short_desc()

const std::string & CoolProp::get_scheme_short_desc ( schemes scheme )

Definition at line 464 of file DataStructures.cpp.

◆ Halley() [1/2]

double CoolProp::Halley	(	FuncWrapper1DWithTwoDerivs &	f,
		double	x0,
		double	ftol,
		int	maxiter,
		double	xtol_rel = `1e-12`
	)

inline

Definition at line 99 of file Solvers.h.

◆ Halley() [2/2]

double CoolProp::Halley	(	FuncWrapper1DWithTwoDerivs *	f,
		double	x0,
		double	ftol,
		int	maxiter,
		double	xtol_rel
	)

In the Halley's method solver, two derivatives of the input variable are needed, it yields the following method:

\[ x_{n+1} = x_n - \frac {2 f(x_n) f'(x_n)} {2 {[f'(x_n)]}^2 - f(x_n) f''(x_n)} \]

http://en.wikipedia.org/wiki/Halley%27s_method

Parameters

f	A pointer to an instance of the FuncWrapper1DWithTwoDerivs class that implements the call() and two derivatives
x0	The initial guess for the solution
ftol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations
xtol_rel	The minimum allowable (relative) step size

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 159 of file Solvers.cpp.

◆ has_backend_in_string()

bool CoolProp::has_backend_in_string	(	const std::string &	fluid_string,
		std::size_t &	i
	)

Definition at line 108 of file CoolProp.cpp.

◆ has_fractions_in_string()

bool CoolProp::has_fractions_in_string ( const std::string & fluid_string )

Definition at line 136 of file CoolProp.cpp.

◆ has_solution_concentration()

bool CoolProp::has_solution_concentration ( const std::string & fluid_string )

Definition at line 140 of file CoolProp.cpp.

◆ Householder4() [1/2]

double CoolProp::Householder4	(	FuncWrapper1DWithThreeDerivs &	f,
		double	x0,
		double	ftol,
		int	maxiter,
		double	xtol_rel = `1e-12`
	)

inline

Definition at line 102 of file Solvers.h.

◆ Householder4() [2/2]

double CoolProp::Householder4	(	FuncWrapper1DWithThreeDerivs *	f,
		double	x0,
		double	ftol,
		int	maxiter,
		double	xtol_rel
	)

In the 4-th order Householder method, three derivatives of the input variable are needed, it yields the following method:

\[ x_{n+1} = x_n - f(x_n)\left( \frac {[f'(x_n)]^2 - f(x_n)f''(x_n)/2 } {[f'(x_n)]^3-f(x_n)f'(x_n)f''(x_n)+f'''(x_n)*[f(x_n)]^2/6 } \right) \]

http://numbers.computation.free.fr/Constants/Algorithms/newton.ps

Parameters

f	A pointer to an instance of the FuncWrapper1DWithThreeDerivs class that implements the call() and three derivatives
x0	The initial guess for the solution
ftol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations
xtol_rel	The minimum allowable (relative) step size

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 227 of file Solvers.cpp.

◆ invert()

template<class T >

std::vector< std::vector< T > > CoolProp::invert ( std::vector< std::vector< T > > const & in )

Definition at line 866 of file MatrixMath.h.

◆ is_predefined_mixture()

bool CoolProp::is_predefined_mixture	(	const std::string &	name,
		Dictionary &	dict
	)

Get the parameters for a predefined mixture - R410A, R404A, etc. if the mixture is predefined.

Definition at line 62 of file MixtureParameters.cpp.

◆ is_Qmass_pair()

bool CoolProp::is_Qmass_pair ( input_pairs p )

inline

Return true if the input pair involves a mass-based quality (Qmass).

Definition at line 352 of file DataStructures.h.

◆ is_squared()

template<class T >

bool CoolProp::is_squared ( std::vector< std::vector< T > > const & in )

Definition at line 58 of file MatrixMath.h.

◆ is_trivial_parameter()

bool CoolProp::is_trivial_parameter ( int key )

Returns true if the input is trivial (constants, critical parameters, etc.)

Definition at line 171 of file DataStructures.cpp.

◆ is_valid_first_derivative()

bool CoolProp::is_valid_first_derivative	(	const std::string &	name,
		parameters &	iOf,
		parameters &	iWrt,
		parameters &	iConstant
	)

Returns true if the string corresponds to a valid first derivative

If it is a value derivative, the variables are set to the parts of the derivative

Definition at line 227 of file DataStructures.cpp.

◆ is_valid_first_saturation_derivative()

bool CoolProp::is_valid_first_saturation_derivative	(	const std::string &	name,
		parameters &	iOf,
		parameters &	iWrt
	)

Returns true if the string corresponds to a valid first saturation derivative - e.g. "d(P)/d(T)|sigma" for instance

If it is a valid derivative, the variables are set to the parts of the derivative

Definition at line 270 of file DataStructures.cpp.

◆ is_valid_fluid_string()

bool CoolProp::is_valid_fluid_string ( const std::string & fluidstring )

Check if the fluid name is valid.

Returns: output Returns true if the fluid string is valid

Note: "gfreilgregre" -> false; "HEOS::Water" -> true; "Water" -> true

Definition at line 921 of file CoolProp.cpp.

◆ is_valid_parameter()

bool CoolProp::is_valid_parameter	(	const std::string &	param_name,
		parameters &	iOutput
	)

Returns true if a valid parameter, and sets value in the variable iOutput.

Definition at line 213 of file DataStructures.cpp.

◆ is_valid_phase()

bool CoolProp::is_valid_phase	(	const std::string &	phase_name,
		phases &	iOutput
	)

Return true if passed phase name is valid, otherwise false

Parameters

phase_name	The phase name string to be checked ("phase_liquid" for instance)
iOutput	Gets updated with the phases enum value if phase_name is found

Definition at line 409 of file DataStructures.cpp.

◆ is_valid_scheme()

bool CoolProp::is_valid_scheme	(	const std::string &	scheme_name,
		schemes &	iOutput
	)

Return true if passed PC-SAFT association scheme name is valid, otherwise false

Parameters

scheme_name	The association scheme string to be checked ("2B" for instance)
iOutput	Gets updated with the schemes enum value if scheme_name is found

Definition at line 473 of file DataStructures.cpp.

◆ is_valid_second_derivative()

bool CoolProp::is_valid_second_derivative	(	const std::string &	name,
		parameters &	iOf1,
		parameters &	iWrt1,
		parameters &	iConstant1,
		parameters &	iWrt2,
		parameters &	iConstant2
	)

Returns true if the string corresponds to a valid second derivative

If it is a value derivative, the variables are set to the parts of the derivative

Definition at line 312 of file DataStructures.cpp.

◆ kahanSum()

CoolPropDbl CoolProp::kahanSum ( const std::vector< CoolPropDbl > & x )

Definition at line 14 of file Helmholtz.cpp.

◆ linsolve() [1/2]

template<class T >

std::vector< std::vector< T > > CoolProp::linsolve	(	std::vector< std::vector< T > > const &	A,
		std::vector< std::vector< T > > const &	B
	)

Definition at line 719 of file MatrixMath.h.

◆ linsolve() [2/2]

template<class T >

std::vector< T > CoolProp::linsolve	(	std::vector< std::vector< T > > const &	A,
		std::vector< T > const &	b
	)

Definition at line 724 of file MatrixMath.h.

◆ linsolve_Gauss_Jordan()

template<typename T >

std::vector< std::vector< T > > CoolProp::linsolve_Gauss_Jordan	(	std::vector< std::vector< T > > const &	A,
		std::vector< std::vector< T > > const &	B
	)

Definition at line 593 of file MatrixMath.h.

◆ load()

void CoolProp::load ( )

Definition at line 46 of file FluidLibrary.cpp.

◆ load_incompressible_library()

void CoolProp::load_incompressible_library ( )

Definition at line 552 of file IncompressibleLibrary.cpp.

◆ load_table()

template<typename T >

void CoolProp::load_table	(	T &	table,
		const std::string &	path_to_tables,
		const std::string &	filename
	)

Parameters

table
path_to_tables
filename

Definition at line 35 of file TabularBackends.cpp.

◆ make_squared()

template<class T >

std::vector< std::vector< T > > CoolProp::make_squared ( std::vector< std::vector< T > > const & in )

Definition at line 759 of file MatrixMath.h.

◆ makeColVector()

template<class T >

Eigen::Matrix< T, Eigen::Dynamic, 1 > CoolProp::makeColVector ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & matrix )

Convert 1D matrix to vector.

Returns either a row- or a column-based vector. By default, Eigen prefers column major ordering, just like Fortran.

Definition at line 181 of file MatrixMath.h.

◆ makeRowVector()

template<class T >

Eigen::Matrix< T, 1, Eigen::Dynamic > CoolProp::makeRowVector ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & matrix )

Definition at line 199 of file MatrixMath.h.

◆ makeVector()

template<class T >

Eigen::Matrix< T, Eigen::Dynamic, 1 > CoolProp::makeVector ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & matrix )

Definition at line 195 of file MatrixMath.h.

◆ mass_to_molar()

void CoolProp::mass_to_molar	(	parameters &	param,
		double &	conversion_factor,
		double	molar_mass
	)

inline

Get a conversion factor from mass to molar if needed.

Definition at line 175 of file TabularBackends.h.

◆ mat_to_string() [1/2]

template<class T >

std::string CoolProp::mat_to_string ( const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & A )

Definition at line 398 of file MatrixMath.h.

◆ mat_to_string() [2/2]

template<class T >

std::string CoolProp::mat_to_string	(	const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	A,
		const char *	fmt
	)

Templates for turning Eigen matrices into strings.

Definition at line 376 of file MatrixMath.h.

◆ match_pair()

bool CoolProp::match_pair	(	parameters	key1,
		parameters	key2,
		parameters	x1,
		parameters	x2,
		bool &	swap
	)

inline

Definition at line 346 of file DataStructures.h.

◆ max_cols()

template<class T >

std::size_t CoolProp::max_cols ( std::vector< std::vector< T > > const & in )

Definition at line 46 of file MatrixMath.h.

◆ minor_matrix()

template<typename Derived >

Eigen::MatrixXd CoolProp::minor_matrix	(	const Eigen::MatrixBase< Derived > &	A,
		std::size_t	i,
		std::size_t	j
	)

inline

Definition at line 902 of file MatrixMath.h.

◆ multiply() [1/3]

template<class T >

std::vector< std::vector< T > > CoolProp::multiply	(	std::vector< std::vector< T > > const &	A,
		std::vector< std::vector< T > > const &	B
	)

Definition at line 810 of file MatrixMath.h.

◆ multiply() [2/3]

template<class T >

std::vector< T > CoolProp::multiply	(	std::vector< std::vector< T > > const &	A,
		std::vector< T > const &	b
	)

Definition at line 796 of file MatrixMath.h.

◆ multiply() [3/3]

template<class T >

T CoolProp::multiply	(	std::vector< T > const &	a,
		std::vector< T > const &	b
	)

Definition at line 792 of file MatrixMath.h.

◆ NDNewtonRaphson_Jacobian()

std::vector< double > CoolProp::NDNewtonRaphson_Jacobian	(	FuncWrapperND *	f,
		const std::vector< double > &	x,
		double	tol,
		int	maxiter,
		double	w
	)

In this formulation of the Multi-Dimensional Newton-Raphson solver the Jacobian matrix is known. Therefore, the dx vector can be obtained from

J(x)dx=-f(x)

for a given value of x. The pointer to the class FuncWrapperND that is passed in must implement the call() and Jacobian() functions, each of which take the vector x. The data is managed using std::vector<double> vectors

Parameters

f	A pointer to an subclass of the FuncWrapperND class that implements the call() and Jacobian() functions
x	The initial guess value for the solution
tol	The root-sum-square of the errors from each of the components
maxiter	The maximum number of iterations
w	A relaxation multiplier on the step size, multiplying the normal step size

Returns: If no errors are found, the solution. Otherwise, _HUGE, the value for infinity

Definition at line 49 of file Solvers.cpp.

◆ Newton() [1/2]

double CoolProp::Newton	(	FuncWrapper1DWithDeriv &	f,
		double	x0,
		double	ftol,
		int	maxiter
	)

inline

Definition at line 96 of file Solvers.h.

◆ Newton() [2/2]

double CoolProp::Newton	(	FuncWrapper1DWithDeriv *	f,
		double	x0,
		double	ftol,
		int	maxiter
	)

In the newton function, a 1-D Newton-Raphson solver is implemented using exact solutions. An initial guess for the solution is provided.

Parameters

f	A pointer to an instance of the FuncWrapper1D class that implements the call() function
x0	The initial guess for the solution
ftol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 108 of file Solvers.cpp.

◆ num_cols() [1/2]

template<class T >

std::size_t CoolProp::num_cols ( std::vector< std::vector< T > > const & in )

Definition at line 77 of file MatrixMath.h.

◆ num_cols() [2/2]

template<class T >

std::size_t CoolProp::num_cols ( std::vector< T > const & in )

Definition at line 73 of file MatrixMath.h.

◆ num_rows() [1/2]

template<class T >

std::size_t CoolProp::num_rows ( std::vector< std::vector< T > > const & in )

Definition at line 41 of file MatrixMath.h.

◆ num_rows() [2/2]

template<class T >

std::size_t CoolProp::num_rows ( std::vector< T > const & in )

Some shortcuts and regularly needed operations.

Definition at line 37 of file MatrixMath.h.

◆ parse_factory_options()

FactoryOptionsParseResult CoolProp::parse_factory_options ( const std::string & factory_string )

Definition at line 21 of file FactoryOptions.cpp.

◆ parse_HMX_BNC()

void CoolProp::parse_HMX_BNC	(	const std::string &	s,
		std::vector< REFPROP_binary_element > &	BIP,
		std::vector< REFPROP_departure_function > &	functions
	)

Definition at line 646 of file MixtureParameters.cpp.

◆ phase_lookup_string()

std::string CoolProp::phase_lookup_string ( phases Phase )

An internal function to extract the phase string, given the phase index; Handy for printing the actual phase string in debug, warning, and error messages.

Parameters

Phase The enumerated phase index to be looked up

< Liquid

< Supercritical (p > pc, T > Tc)

< Supercritical gas (p < pc, T > Tc)

< Supercritical liquid (p > pc, T < Tc)

< At the critical point

< Subcritical gas

< Twophase (between saturation curves - inclusive)

< Unknown phase

Definition at line 1168 of file CoolProp.cpp.

◆ PhaseSI()

std::string CoolProp::PhaseSI	(	const std::string &	Name1,
		double	Prop1,
		const std::string &	Name2,
		double	Prop2,
		const std::string &	FluidName
	)

Return a string representation of the phase

Parameters

Name1	The first state variable name, one of "T","D","H",etc.
Prop1	The first state variable value
Name2	The second state variable name, one of "T","D","H",etc.
Prop2	The second state variable value
FluidName	The fluid name

Note: Returns empty string if there was an error; use get_global_param_string("errstring") to retrieve the error

Definition at line 1191 of file CoolProp.cpp.

◆ Props1SI()

double CoolProp::Props1SI	(	std::string	FluidName,
		std::string	Output
	)

Return a value that does not depend on the thermodynamic state - this is a convenience function that does the call PropsSI(Output, "", 0, "", 0, FluidName)

Parameters

FluidName	The fluid name
Output	The output parameter, one of "Tcrit","D","H",etc.

Definition at line 866 of file CoolProp.cpp.

◆ Props1SImulti()

std::vector< std::vector< double > > CoolProp::Props1SImulti	(	const std::vector< std::string > &	Outputs,
		const std::string &	backend,
		const std::vector< std::string > &	fluids,
		const std::vector< double > &	fractions
	)

Get a matrix of outputs that do not depend on the thermodynamic state - this is a convenience function that does the call PropsSImulti(Outputs, "", {0}, "", {0}, backend, fluids, fractions)

Parameters

Outputs	A vector of strings for the output parameters
backend	The string representation of the backend (HEOS, REFPROP, INCOMP, etc.)
fluids	The fluid name(s)
fractions	The fractions (molar, mass, volume, etc.) of the components

Definition at line 893 of file CoolProp.cpp.

◆ PropsSI()

double CoolProp::PropsSI	(	const std::string &	Output,
		const std::string &	Name1,
		double	Prop1,
		const std::string &	Name2,
		double	Prop2,
		const std::string &	FluidName
	)

Return a value that depends on the thermodynamic state

Parameters

Output	The output parameter, one of "T","D","H",etc.
Name1	The first state variable name, one of "T","D","H",etc.
Prop1	The first state variable value
Name2	The second state variable name, one of "T","D","H",etc.
Prop2	The second state variable value
FluidName	The fluid name

Definition at line 654 of file CoolProp.cpp.

◆ PropsSImulti()

std::vector< std::vector< double > > CoolProp::PropsSImulti	(	const std::vector< std::string > &	Outputs,
		const std::string &	Name1,
		const std::vector< double > &	Prop1,
		const std::string &	Name2,
		const std::vector< double > &	Prop2,
		const std::string &	backend,
		const std::vector< std::string > &	fluids,
		const std::vector< double > &	fractions
	)

Get a matrix of outputs for a given input. Can handle both vector inputs as well as a vector of output strings.

Parameters

Outputs	A vector of strings for the output parameters
Name1	The name of the first input variable
Prop1	A vector of the first input values
Name2	The name of the second input variable
Prop2	A vector of the second input values
backend	The string representation of the backend (HEOS, REFPROP, INCOMP, etc.)
fluids	The fluid name(s)
fractions	The fractions (molar, mass, volume, etc.) of the components

Definition at line 622 of file CoolProp.cpp.

◆ ramp()

double CoolProp::ramp ( double x )

Definition at line 30 of file Helmholtz.cpp.

◆ REFPROP_SETREF()

void CoolProp::REFPROP_SETREF	(	char *	hrf,
		int	ixflag,
		double *	x0,
		double &	h0,
		double &	s0,
		double &	T0,
		double &	p0,
		int &	ierr,
		char *	herr,
		int	l1,
		int	l2
	)

Definition at line 2815 of file REFPROPMixtureBackend.cpp.

◆ register_backend()

void CoolProp::register_backend	(	const backend_families &	bf,
		const shared_ptr< AbstractStateGenerator > &	gen
	)

Register a backend in the backend library (statically defined in AbstractState.cpp and not publicly accessible)

Definition at line 60 of file AbstractState.cpp.

◆ removeColumn() [1/2]

template<class T >

void CoolProp::removeColumn	(	Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	matrix,
		std::size_t	colToRemove
	)

Definition at line 236 of file MatrixMath.h.

◆ removeColumn() [2/2]

void CoolProp::removeColumn	(	Eigen::MatrixXd &	matrix,
		unsigned int	colToRemove
	)

inline

Definition at line 890 of file MatrixMath.h.

◆ removeRow() [1/2]

template<class T >

void CoolProp::removeRow	(	Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &	matrix,
		std::size_t	rowToRemove
	)

Remove rows and columns from matrices.

A set of convenience functions inspired by http://stackoverflow.com/questions/13290395/how-to-remove-a-certain-row-or-column-while-using-eigen-library-c but altered to respect templates.

Definition at line 218 of file MatrixMath.h.

◆ removeRow() [2/2]

void CoolProp::removeRow	(	Eigen::MatrixXd &	matrix,
		unsigned int	rowToRemove
	)

inline

Definition at line 878 of file MatrixMath.h.

◆ saturation_ancillary()

double CoolProp::saturation_ancillary	(	const std::string &	fluid_name,
		const std::string &	output,
		int	Q,
		const std::string &	input,
		double	value
	)

Definition at line 935 of file CoolProp.cpp.

◆ Secant() [1/2]

double CoolProp::Secant	(	FuncWrapper1D &	f,
		double	x0,
		double	dx,
		double	ftol,
		int	maxiter
	)

inline

Definition at line 86 of file Solvers.h.

◆ Secant() [2/2]

double CoolProp::Secant	(	FuncWrapper1D *	f,
		double	x0,
		double	dx,
		double	tol,
		int	maxiter
	)

In the secant function, a 1-D Newton-Raphson solver is implemented. An initial guess for the solution is provided.

Parameters

f	A pointer to an instance of the FuncWrapper1D class that implements the call() function
x0	The initial guess for the solutionh
dx	The initial amount that is added to x in order to build the numerical derivative
tol	The absolute value of the tolerance accepted for the objective function
maxiter	Maximum number of iterations

Returns: If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

Definition at line 288 of file Solvers.cpp.

◆ set_config_as_json_string()

void CoolProp::set_config_as_json_string ( const std::string & s )

Set the entire configuration based on a json-formatted string.

Definition at line 170 of file Configuration.cpp.

◆ set_config_bool()

void CoolProp::set_config_bool	(	configuration_keys	key,
		bool	val
	)

Set the value of a boolean configuration value.

SETTERS

Definition at line 135 of file Configuration.cpp.

◆ set_config_double()

void CoolProp::set_config_double	(	configuration_keys	key,
		double	val
	)

Set the value of a double configuration value.

Definition at line 141 of file Configuration.cpp.

◆ set_config_int()

void CoolProp::set_config_int	(	configuration_keys	key,
		int	val
	)

Set the value of an integer configuration value.

Definition at line 138 of file Configuration.cpp.

◆ set_config_string()

void CoolProp::set_config_string	(	configuration_keys	key,
		const std::string &	val
	)

Set the value of a string configuration value.

Definition at line 144 of file Configuration.cpp.

◆ set_debug_level()

void CoolProp::set_debug_level ( int level )

Set the debug level

Parameters

level The level of the verbosity for the debugging output (0-10) 0: no debgging output

Definition at line 87 of file CoolProp.cpp.

◆ set_departure_functions()

void CoolProp::set_departure_functions ( const std::string & string_data )

Set the departure functions in the departure function library from a string format.

Parameters

string_data The departure functions to be set, either provided as a JSON-formatted string or as a string of the contents of a HMX.BNC file from REFPROP

Note: By default, if a departure function already exists in the library, this is an error, unless the configuration variable OVERWRITE_DEPARTURE_FUNCTIONS is set to true

Definition at line 792 of file MixtureParameters.cpp.

◆ set_error_string()

void CoolProp::set_error_string ( const std::string & error )

Set the global error string

Parameters

error The error string to use

Definition at line 102 of file CoolProp.cpp.

◆ set_fluid_enthalpy_entropy_offset()

void CoolProp::set_fluid_enthalpy_entropy_offset	(	const std::string &	fluid,
		double	delta_a1,
		double	delta_a2,
		const std::string &	ref
	)

Set the internal enthalpy and entropy offset variables.

Definition at line 391 of file FluidLibrary.cpp.

◆ set_interaction_parameters()

void CoolProp::set_interaction_parameters ( const std::string & string_data )

Set the interaction parameters from a string format.

Parameters

string_data The model parameters, as a JSON-formatted string

Definition at line 396 of file MixtureParameters.cpp.

◆ set_mixture_binary_pair_data()

void CoolProp::set_mixture_binary_pair_data	(	const std::string &	CAS1,
		const std::string &	CAS2,
		const std::string &	param,
		const double	val
	)

Set a parameter for the given binary pair.

Parameters

CAS1	The CAS # for the first fluid (order matters!)
CAS2	The CAS # for the second fluid (order matters!)
param	The parameter you want to set
val	The value of the parameter

Definition at line 353 of file MixtureParameters.cpp.

◆ set_mixture_binary_pair_pcsaft()

void CoolProp::set_mixture_binary_pair_pcsaft	(	const std::string &	CAS1,
		const std::string &	CAS2,
		const std::string &	key,
		const double	value
	)

Definition at line 21 of file PCSAFTLibrary.cpp.

◆ set_predefined_mixtures()

void CoolProp::set_predefined_mixtures ( const std::string & string_data )

Set predefined mixtures at runtime.

Parameters

string_data The predefined mixtures, as a JSON-formatted string

Definition at line 72 of file MixtureParameters.cpp.

◆ set_reference_stateD()

void CoolProp::set_reference_stateD	(	const std::string &	FluidName,
		double	T,
		double	rhomolar,
		double	hmolar0,
		double	smolar0
	)

Set the reference state based on a thermodynamic state point specified by temperature and molar density

Parameters

FluidName	The name of the fluid
T	Temperature at reference state [K]
rhomolar	Molar density at reference state [mol/m^3]
hmolar0	Molar enthalpy at reference state [J/mol]
smolar0	Molar entropy at reference state [J/mol/K]

Definition at line 1028 of file CoolProp.cpp.

◆ set_reference_stateS()

void CoolProp::set_reference_stateS	(	const std::string &	FluidName,
		const std::string &	reference_state
	)

Set the reference state based on a string representation.

Parameters

FluidName	The name of the fluid (Backend can be provided like "REFPROP::Water", or if no backend is provided, "HEOS" is the assumed backend)
reference_state	The reference state to use, one of

Reference State	Description
"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 @ 1.0 bar saturated liquid
"DEF"	Reset to the default reference state for the fluid
"RESET"	Remove the offset

The offset in the ideal gas Helmholtz energy can be obtained from

\[ \displaystyle\frac{\Delta s}{R_u/M}+\frac{\Delta h}{(R_u/M)T}\tau \]

where \( \Delta s = s-s_{spec} \) and \( \Delta h = h-h_{spec} \)

Definition at line 946 of file CoolProp.cpp.

◆ set_warning_string()

void CoolProp::set_warning_string ( const std::string & warning )

An internal function to set the global warning string

Parameters

warning The string to set as the warning string

Definition at line 98 of file CoolProp.cpp.

◆ sign()

CoolPropDbl CoolProp::sign ( CoolPropDbl x )

Definition at line 925 of file VLERoutines.cpp.

◆ Skip_if_No_REFPROP()

void CoolProp::Skip_if_No_REFPROP ( )

A function to skip tests that require REFPROPMixtureBackend in environments where it is not supported (e.g., CI builds on GitHub)

Definition at line 720 of file CoolProp.cpp.

◆ split_input_pair()

void CoolProp::split_input_pair	(	input_pairs	pair,
		parameters &	p1,
		parameters &	p2
	)

Split an input pair into parameters for the two parts that form the pair.

Definition at line 610 of file DataStructures.cpp.

◆ stringvec_to_string()

std::string CoolProp::stringvec_to_string ( const std::vector< std::string > & a )

inline

Templates for turning vectors (1D-matrices) into strings.

Definition at line 334 of file MatrixMath.h.

◆ StripPhase()

bool CoolProp::StripPhase	(	std::string &	Name,
		shared_ptr< AbstractState > &	State
	)

Definition at line 532 of file CoolProp.cpp.

◆ subtract_row_multiple()

template<typename T >

void CoolProp::subtract_row_multiple	(	std::vector< std::vector< T > > *	A,
		size_t	row,
		T	multiple,
		size_t	pivot_row
	)

Definition at line 565 of file MatrixMath.h.

◆ swap_rows()

template<typename T >

void CoolProp::swap_rows	(	std::vector< std::vector< T > > *	A,
		size_t	row1,
		size_t	row2
	)

Template class for turning numbers (0D-matrices) into strings.

Definition at line 559 of file MatrixMath.h.

◆ to_canonical_json_str()

std::string CoolProp::to_canonical_json_str ( const std::string & json_str )

Definition at line 19 of file SchemaValidation.cpp.

◆ to_hex16()

std::string CoolProp::to_hex16 ( std::uint64_t h )

inline

Definition at line 42 of file Hash.h.

◆ transpose()

template<class T >

std::vector< std::vector< T > > CoolProp::transpose ( std::vector< std::vector< T > > const & in )

Definition at line 848 of file MatrixMath.h.

◆ validate_json_against_schema()

void CoolProp::validate_json_against_schema	(	const std::string &	instance_json,
		const std::string &	schema_json
	)

Definition at line 10 of file SchemaValidation.cpp.

◆ vec_to_eigen() [1/3]

template<class T >

Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > CoolProp::vec_to_eigen ( const std::vector< std::vector< T > > & coefficients )

Parameters

coefficients matrix containing the ordered coefficients

Definition at line 136 of file MatrixMath.h.

◆ vec_to_eigen() [2/3]

template<class T >

Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > CoolProp::vec_to_eigen	(	const std::vector< T > &	coefficients,
		int	axis = `0`
	)

Parameters

coefficients	matrix containing the ordered coefficients
axis	axis along which to extract data

Definition at line 151 of file MatrixMath.h.

◆ vec_to_eigen() [3/3]

template<class T >

Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > CoolProp::vec_to_eigen ( const T & coefficient )

Parameters

coefficient

Definition at line 168 of file MatrixMath.h.

◆ vec_to_string() [1/6]

template<class T >

std::string CoolProp::vec_to_string ( const std::vector< std::vector< T > > & A )

Definition at line 370 of file MatrixMath.h.

◆ vec_to_string() [2/6]

template<class T >

std::string CoolProp::vec_to_string	(	const std::vector< std::vector< T > > &	A,
		const char *	fmt
	)

Templates for turning 2D-matrices into strings.

Definition at line 359 of file MatrixMath.h.

◆ vec_to_string() [3/6]

template<class T >

std::string CoolProp::vec_to_string ( const std::vector< T > & a )

Definition at line 330 of file MatrixMath.h.

◆ vec_to_string() [4/6]

template<class T >

std::string CoolProp::vec_to_string	(	const std::vector< T > &	a,
		const char *	fmt
	)

Templates for turning vectors (1D-matrices) into strings.

Definition at line 319 of file MatrixMath.h.

◆ vec_to_string() [5/6]

template<class T >

std::string CoolProp::vec_to_string ( const T & a )

Definition at line 353 of file MatrixMath.h.

◆ vec_to_string() [6/6]

template<class T >

std::string CoolProp::vec_to_string	(	const T &	a,
		const char *	fmt
	)

Templates for turning numbers (0D-matrices) into strings.

Definition at line 347 of file MatrixMath.h.

◆ vecstring_to_string()

std::string CoolProp::vecstring_to_string ( const std::vector< std::string > & a )

inline

Templates for turning vectors (1D-matrices) into strings.

Definition at line 20 of file HelmholtzEOSBackend.h.

◆ wayToSort()

bool CoolProp::wayToSort	(	CoolPropDbl	i,
		CoolPropDbl	j
	)

Definition at line 25 of file Helmholtz.cpp.

◆ write_table()

template<typename T >

void CoolProp::write_table	(	const T &	table,
		const std::string &	path_to_tables,
		const std::string &	name
	)

Definition at line 92 of file TabularBackends.cpp.

◆ Xdd()

double CoolProp::Xdd	(	double	X,
		double	delta,
		double	Delta,
		double	Delta_d,
		double	Delta_dd
	)

Definition at line 964 of file Helmholtz.cpp.

Variable Documentation

◆ backend_family_list

const std::vector<backend_family_info> CoolProp::backend_family_list

Initial value:

= {
  {HEOS_BACKEND_FAMILY, "HEOS"},   {REFPROP_BACKEND_FAMILY, "REFPROP"}, {INCOMP_BACKEND_FAMILY, "INCOMP"},   {IF97_BACKEND_FAMILY, "IF97"},
  {TREND_BACKEND_FAMILY, "TREND"}, {TTSE_BACKEND_FAMILY, "TTSE"},       {BICUBIC_BACKEND_FAMILY, "BICUBIC"}, {SRK_BACKEND_FAMILY, "SRK"},
  {PR_BACKEND_FAMILY, "PR"},       {VTPR_BACKEND_FAMILY, "VTPR"},       {PCSAFT_BACKEND_FAMILY, "PCSAFT"},   {SVDSBTL_BACKEND_FAMILY, "SVDSBTL"}}

Definition at line 802 of file DataStructures.cpp.

◆ backend_information_p

std::unique_ptr<BackendInformation> CoolProp::backend_information_p

Definition at line 846 of file DataStructures.cpp.

◆ backend_list

const std::vector<backend_info> CoolProp::backend_list

Initial value:

= {{HEOS_BACKEND_PURE, "HelmholtzEOSBackend", HEOS_BACKEND_FAMILY},
                                                {HEOS_BACKEND_MIX, "HelmholtzEOSMixtureBackend", HEOS_BACKEND_FAMILY},
                                                {REFPROP_BACKEND_PURE, "REFPROPBackend", REFPROP_BACKEND_FAMILY},
                                                {REFPROP_BACKEND_MIX, "REFPROPMixtureBackend", REFPROP_BACKEND_FAMILY},
                                                {INCOMP_BACKEND, "IncompressibleBackend", INCOMP_BACKEND_FAMILY},
                                                {IF97_BACKEND, "IF97Backend", IF97_BACKEND_FAMILY},
                                                {TREND_BACKEND, "TRENDBackend", TREND_BACKEND_FAMILY},
                                                {TTSE_BACKEND, "TTSEBackend", TTSE_BACKEND_FAMILY},
                                                {BICUBIC_BACKEND, "BicubicBackend", BICUBIC_BACKEND_FAMILY},
                                                {SRK_BACKEND, "SRKBackend", SRK_BACKEND_FAMILY},
                                                {PR_BACKEND, "PengRobinsonBackend", PR_BACKEND_FAMILY},
                                                {VTPR_BACKEND, "VTPRBackend", VTPR_BACKEND_FAMILY},
                                                {PCSAFT_BACKEND, "PCSAFTBackend", PCSAFT_BACKEND_FAMILY},
                                                {SVDSBTL_BACKEND, "SVDSBTLBackend", SVDSBTL_BACKEND_FAMILY}}

Definition at line 807 of file DataStructures.cpp.

◆ CPPOLY_DELTA

constexpr double CoolProp::CPPOLY_DELTA = CPPOLY_EPSILON * 10.0

constexpr

Definition at line 21 of file PolyMath.cpp.

◆ CPPOLY_EPSILON

constexpr double CoolProp::CPPOLY_EPSILON = DBL_EPSILON * 100.0

constexpr

Definition at line 20 of file PolyMath.cpp.

◆ input_pair_information_p

std::unique_ptr<InputPairInformation> CoolProp::input_pair_information_p

Definition at line 577 of file DataStructures.cpp.

◆ input_pair_list

const input_pair_info CoolProp::input_pair_list[]

Definition at line 510 of file DataStructures.cpp.

◆ parameter_info_list

const std::vector<parameter_info> CoolProp::parameter_info_list

Definition at line 18 of file DataStructures.cpp.

◆ parameter_information_p

std::unique_ptr<ParameterInformation> CoolProp::parameter_information_p

Definition at line 163 of file DataStructures.cpp.

◆ pconfig

std::unique_ptr<Configuration> CoolProp::pconfig

Definition at line 126 of file Configuration.cpp.

◆ phase_info_list

const phase_info CoolProp::phase_info_list[]

Initial value:

= {
  {iphase_liquid, "phase_liquid", ""},
  {iphase_gas, "phase_gas", ""},
  {iphase_twophase, "phase_twophase", ""},
  {iphase_supercritical, "phase_supercritical", ""},
  {iphase_supercritical_gas, "phase_supercritical_gas", "p < pc, T > Tc"},
  {iphase_supercritical_liquid, "phase_supercritical_liquid", "p > pc, T < Tc"},
  {iphase_critical_point, "phase_critical_point", "p = pc, T = Tc"},
  {iphase_unknown, "phase_unknown", ""},
  {iphase_not_imposed, "phase_not_imposed", ""},
}

Definition at line 366 of file DataStructures.cpp.

◆ phase_information_p

std::unique_ptr<PhaseInformation> CoolProp::phase_information_p

Definition at line 393 of file DataStructures.cpp.

◆ scheme_info_list

const scheme_info CoolProp::scheme_info_list[]

Initial value:

= {
  {i1, "1"}, {i2a, "2A"}, {i2b, "2B"}, {i3a, "3A"}, {i3b, "3B"}, {i4a, "4A"}, {i4b, "4B"}, {i4c, "4C"},
}

Definition at line 438 of file DataStructures.cpp.

◆ scheme_information_p

std::unique_ptr<SchemeInformation> CoolProp::scheme_information_p

Definition at line 456 of file DataStructures.cpp.

Detailed Description

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AttributeError

◆ CompositionError

◆ DepartureFunctionPointer

◆ DirectorySizeError

◆ HandleError

◆ InputError

◆ KeyError

◆ mat

◆ MultipleSolutionsError

◆ NotAvailableError

◆ NotImplementedError

◆ OutOfRangeError

◆ SolutionError

◆ STLMatrix

◆ UnableToLoadError

◆ ValueError

◆ WrongFluidError

Enumeration Type Documentation

◆ backend_families

◆ backends

◆ composition_types

◆ fast_evaluate_status

◆ fluid_types

◆ input_pairs

◆ parameters

Define some constants that will be used throughout

◆ phases

◆ schemes

◆ x_N_dependency_flag

Function Documentation

◆ _get_config()

◆ _PropsSI_initialize()

◆ _PropsSI_outputs()

◆ _PropsSImulti()

◆ add_fluids_as_JSON()

◆ apply_simple_mixing_rule()

◆ BoundedSecant() [1/2]

◆ BoundedSecant() [2/2]

◆ Brent() [1/2]

◆ Brent() [2/2]

◆ compare_REFPROP_and_CoolProp() [1/2]

◆ compare_REFPROP_and_CoolProp() [2/2]

◆ config_key_description() [1/2]

◆ config_key_description() [2/2]

◆ config_key_to_string()

◆ config_string_to_key()

◆ cross_product()

◆ divide_row_by()

◆ dot_product()

◆ eigen_to_vec()

◆ eigen_to_vec1D()

◆ ERR_NOT_A_TWO_PHASE_FLUID()

◆ ERR_NOT_A_TWO_PHASE_FUNCTION()

◆ ERR_NOT_A_TWO_PHASE_STATE()

◆ ERR_NOT_COMPRESSIBLE()

◆ extract_backend()

◆ extract_backend_families()

◆ extract_backend_families_string()

◆ extract_fractions()

◆ ExtrapolatingSecant() [1/2]

◆ ExtrapolatingSecant() [2/2]

◆ fnv1a_64() [1/2]

◆ fnv1a_64() [2/2]

◆ force_load_REFPROP()

◆ force_unload_REFPROP()

◆ generate_update_pair()

◆ get_backend_information()

◆ get_backend_library()

◆ get_backend_string()

◆ get_col()

◆ get_config_as_json_string()

◆ get_config_bool()