CoolProp
Classes | Typedefs | Enumerations | Functions | Variables
CoolProp Namespace Reference

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.

Code for all the binary pairs in the mixture.

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

This includes both binary pair information for the reducing functions as well as the departure functions for the given binary pair.

Classes

class  AbstractCubicBackend
 
class  AbstractState
 The mother of all state classes. More...
 
class  AbstractStateGenerator
 An abstract AbstractState generator class. More...
 
struct  Ancillaries
 
struct  backend_family_info
 
struct  backend_info
 
class  BackendInformation
 
class  BackendLibrary
 This tiny class holds pointers to generators for the backends and can be used to look up generators at runtime. More...
 
class  BaseHelmholtzContainer
 
class  BaseHelmholtzTerm
 The base class class for the Helmholtz energy terms. More...
 
struct  BibTeXKeysStruct
 
class  BicubicBackend
 
class  BoyleCurveTracer
 
class  CachedElement
 
class  CellCoeffs
 This structure holds the coefficients for one cell, the coefficients are stored in matrices and can be obtained by the get() function. More...
 
struct  ConductivityCriticalSimplifiedOlchowySengersData
 
struct  ConductivityCriticalVariables
 
struct  ConductivityDiluteEta0AndPolyData
 
struct  ConductivityDiluteRatioPolynomialsData
 
struct  ConductivityDiluteVariables
 
struct  ConductivityECSVariables
 
struct  ConductivityResidualPolynomialAndExponentialData
 
struct  ConductivityResidualPolynomialData
 
struct  ConductivityResidualVariables
 
class  Configuration
 
class  ConfigurationItem
 A class that contains one entry in configuration Can be cast to yield the output value. More...
 
class  ConstantReducingFunction
 A constant reducing function that does not vary with composition. 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
 This class implements all the derivatives of the Helmholtz energy (as well as composition derivatives) that are required for the cubic backends. More...
 
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...
 
class  FlashRoutines
 This class is a friend class of HelmholtzEOSMixtureBackend, therefore the static methods contained in it have access to the private and protected variables in the HelmholtzEOSMixtureBackend instance. More...
 
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
 This simple class holds the values for guesses for use in some solvers that have the ability to use guess values intelligently. More...
 
struct  HelmholtzDerivatives
 
class  HelmholtzEOSBackend
 
class  HelmholtzEOSMixtureBackend
 
class  HEOSGenerator
 
class  IdealCurveTracer
 
class  IdealHelmholtzContainer
 Term in the ideal-gas specific heat equation that is based on Aly-Lee formulation ** Specific heat is of the form: More...
 
class  IdealHelmholtzCP0Constant
 
class  IdealHelmholtzCP0PolyT
 
class  IdealHelmholtzEnthalpyEntropyOffset
 The term in the EOS used to shift the reference state of the fluid. More...
 
class  IdealHelmholtzLead
 The leading term in the EOS used to set the desired reference state. More...
 
class  IdealHelmholtzLogTau
 

\[ \alpha^0 = a_1\ln\tau \]

More...
 
class  IdealHelmholtzPlanckEinsteinGeneralized
 

\[ \alpha^0 = \displaystyle\sum_i n_i\log[c_i+d_i\exp(\theta_i\tau)] \]

More...
 
class  IdealHelmholtzPower
 

\[ \alpha^0 = \displaystyle\sum_i n_i\tau^{t_i} \]

More...
 
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
 Class to access Lithium-Bromide solutions ** Employs some basic wrapper-like functionality. More...
 
class  L0CurveTracer
 This class is used to trace the spinodal of the mixture, and is also used to calculate critical points. More...
 
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...
 
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
 This class is a friend class of HelmholtzEOSMixtureBackend, therefore the static methods contained in it have access to the private and protected variables in the HelmholtzEOSMixtureBackend instance. More...
 
class  MixtureParameters
 
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  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
 A residual function for the f(P, Y) solver. More...
 
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
 This backend is used for pure and pseudo-pure fluids powered by REFPROP. More...
 
class  REFPROPGenerator
 
class  REFPROPMixtureBackend
 
class  ResidualHelmholtz
 This class contains the two primary contributions to the residual Helmholtz energy - a corresponding states contribution, sometimes (incorrectly) referred to as ideal mixing, and an excess term. More...
 
class  ResidualHelmholtzContainer
 
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
 This is generalized class that can be used to manage an ancillary curve, here they are ancillary curves for saturation pressure, density, enthalpy, entropy. More...
 
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
 A residual function for the rho(T,P) solver. More...
 
class  SolverTPResid
 
class  SpinodalData
 This structure holds values obtained while tracing the spinodal curve (most often in the process of finding critical points, but not only) More...
 
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
 The surface tension correlation class uses correlations for the surface tension that are all of the form. More...
 
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...
 
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

typedef CoolPropError< CoolPropBaseError::eNotImplemented > NotImplementedError
 
typedef CoolPropError< CoolPropBaseError::eSolution > SolutionError
 
typedef CoolPropError< CoolPropBaseError::eAttribute > AttributeError
 
typedef CoolPropError< CoolPropBaseError::eOutOfRange > OutOfRangeError
 
typedef CoolPropError< CoolPropBaseError::eValue > ValueError
 
typedef CoolPropError< CoolPropBaseError::eKey > KeyError
 
typedef CoolPropError< CoolPropBaseError::eHandle > HandleError
 
typedef CoolPropError< CoolPropBaseError::eUnableToLoad > UnableToLoadError
 
typedef CoolPropError< CoolPropBaseError::eDirectorySize > DirectorySizeError
 
typedef ValueErrorSpec< CoolPropBaseError::eWrongFluid > WrongFluidError
 
typedef ValueErrorSpec< CoolPropBaseError::eComposition > CompositionError
 
typedef ValueErrorSpec< CoolPropBaseError::eInput > InputError
 
typedef ValueErrorSpec< CoolPropBaseError::eNotAvailable > NotAvailableError
 
typedef std::vector< std::vector< CoolPropDbl > > STLMatrix
 
typedef shared_ptr< DepartureFunctionDepartureFunctionPointer
 
typedef std::vector< std::vector< double > > mat
 This class implements bicubic interpolation, as very clearly laid out by the page on wikipedia: http://en.wikipedia.org/wiki/Bicubic_interpolation. More...
 

Enumerations

enum  parameters {
  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, iTau, iDelta,
  iDmolar, iHmolar, iSmolar, iCpmolar,
  iCp0molar, iCvmolar, iUmolar, iGmolar,
  iHelmholtzmolar, iSmolar_residual, iDmass, iHmass,
  iSmass, iCpmass, iCp0mass, iCvmass,
  iUmass, iGmass, iHelmholtzmass, 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, iBvirial, iCvirial,
  idBvirial_dT, idCvirial_dT, iZ, iPIP,
  ifraction_min, ifraction_max, iT_freeze, iGWP20,
  iGWP100, iGWP500, iFH, iHH,
  iPH, iODP, iPhase, iundefined_parameter
}
 

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. More...
 
enum  phases {
  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  composition_types {
  IFRAC_MASS, IFRAC_MOLE, IFRAC_VOLUME, IFRAC_UNDEFINED,
  IFRAC_PURE
}
 These are constants for the compositions.
 
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.
 
enum  input_pairs {
  INPUT_PAIR_INVALID = 0, QT_INPUTS, PQ_INPUTS, QSmolar_INPUTS,
  QSmass_INPUTS, HmolarQ_INPUTS, HmassQ_INPUTS, DmolarQ_INPUTS,
  DmassQ_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 {
  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
}
 The structure is taken directly from the AbstractState class.
 
enum  backends {
  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
}
 
enum  x_N_dependency_flag { XN_INDEPENDENT, XN_DEPENDENT }
 

Functions

void register_backend (const backend_families &bf, shared_ptr< AbstractStateGenerator > gen)
 Register a backend in the backend library (statically defined in AbstractState.cpp and not publicly accessible)
 
std::string config_key_to_string (configuration_keys keys)
 Convert the configuration key to a string in a 1-1 representation.
 
configuration_keys config_string_to_key (const std::string &s)
 Convert a string description to a configuration key. More...
 
std::string config_key_description (configuration_keys keys)
 Return a string description of the configuration key.
 
std::string config_key_description (const std::string &key)
 Return a string description of the configuration key (with the key passed as a string)
 
bool get_config_bool (configuration_keys key)
 

GETTERS


More...
 
int get_config_int (configuration_keys key)
 Return the value of an integer key from the configuration.
 
double get_config_double (configuration_keys key)
 Return the value of a double configuration key.
 
std::string get_config_string (configuration_keys key)
 Return the value of a string configuration key.
 
void get_config_as_json (rapidjson::Document &doc)
 
std::string get_config_as_json_string ()
 Get all the values in the configuration as a json-formatted string.
 
void set_config_bool (configuration_keys key, bool val)
 

SETTERS


More...
 
void set_config_int (configuration_keys key, int val)
 Set the value of an integer configuration value.
 
void set_config_double (configuration_keys key, double val)
 Set the value of a double configuration value.
 
void set_config_string (configuration_keys key, const std::string &val)
 Set the value of a string configuration value.
 
void set_config_json (rapidjson::Document &doc)
 Set values in the configuration based on a json file.
 
void set_config_as_json_string (const std::string &s)
 Set the entire configuration based on a json-formatted string.
 
double 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) More...
 
double 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. More...
 
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. More...
 
int get_debug_level ()
 Get the debug level. More...
 
void set_debug_level (int level)
 Set the debug level. More...
 
void set_error_string (const std::string &error)
 Set the global error string. More...
 
void set_warning_string (const std::string &warning)
 An internal function to set the global warning string. More...
 
double saturation_ancillary (const std::string &fluid_name, const std::string &output, int Q, const std::string &input, double value)
 
std::string get_global_param_string (const std::string &ParamName)
 Get a globally-defined string. More...
 
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...
 
bool is_valid_fluid_string (const std::string &fluidstring)
 Check if the fluid name is valid. More...
 
bool add_fluids_as_JSON (const std::string &backend, const std::string &fluidstring)
 Add fluids as a JSON-formatted string. More...
 
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)
 Set the reference state based on a thermodynamic state point specified by temperature and molar density. More...
 
std::string PhaseSI (const std::string &Name1, double Prop1, const std::string &Name2, double Prop2, const std::string &FluidName)
 Return a string representation of the phase. More...
 
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". More...
 
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...
 
std::string 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. More...
 
std::string get_parameter_information (int key, const std::string &info)
 Return information about the parameter. More...
 
parameters get_parameter_index (const std::string &param_name)
 Return the enum key corresponding to the parameter name ("Dmolar" for instance)
 
bool is_valid_phase (const std::string &phase_name, phases &iOutput)
 Return true if passed phase name is valid, otherwise false. More...
 
phases get_phase_index (const std::string &param_name)
 Return the enum key corresponding to the phase name ("phase_liquid" for instance)
 
bool is_trivial_parameter (int key)
 Returns true if the input is trivial (constants, critical parameters, etc.)
 
bool is_valid_parameter (const std::string &name, parameters &iOutput)
 Returns true if a valid parameter, and sets value in the variable iOutput.
 
bool 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. More...
 
bool 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. More...
 
bool 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. More...
 
std::string get_csv_parameter_list ()
 Get a comma separated list of parameters. More...
 
bool match_pair (parameters key1, parameters key2, parameters x1, parameters x2, bool &swap)
 
template<class T >
CoolProp::input_pairs generate_update_pair (parameters key1, T value1, parameters key2, T value2, T &out1, T &out2) throw ()
 Generate an update pair from key, value pairs. More...
 
input_pairs get_input_pair_index (const std::string &input_pair_name)
 Get the input pair index associated with its string representation.
 
const std::string & get_input_pair_short_desc (input_pairs pair)
 Return the short description of an input pair key ("DmolarT_INPUTS" for instance)
 
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)
 
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.
 
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...
 
void extract_backend_families (std::string backend_string, backend_families &f1, backend_families &f2)
 Convert a string into the enum values.
 
void extract_backend_families_string (std::string backend_string, backend_families &f1, std::string &f2)
 
std::string get_backend_string (backends backend)
 
template<class T >
std::size_t num_rows (std::vector< T > const &in)
 Some shortcuts and regularly needed operations.
 
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.
 
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.
 
template<class T >
std::string vec_to_string (const T &a, const char *fmt)
 Templates for turning numbers (0D-matrices) into strings.
 
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.
 
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.
 
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.
 
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 >
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 >
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)
 This function implements a 1-D bounded solver using the algorithm from Brent, R. More...
 
double Secant (FuncWrapper1D *f, double x0, double dx, double tol, int maxiter)
 In the secant function, a 1-D Newton-Raphson solver is implemented. More...
 
double 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. More...
 
double Newton (FuncWrapper1DWithDeriv *f, double x0, double ftol, int maxiter)
 In the newton function, a 1-D Newton-Raphson solver is implemented using exact solutions. More...
 
double 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: More...
 
double 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: More...
 
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 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)
 
std::vector< double > 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. More...
 
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)
 
BackendLibraryget_backend_library ()
 
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 ()
 
JSONFluidLibraryget_library (void)
 Get a reference to the library instance.
 
CoolPropFluid get_fluid (const std::string &fluid_string)
 Get the fluid structure.
 
std::string get_fluid_as_JSONstring (const std::string &indentifier)
 Get the fluid as a JSON string, suitable for modification and reloading.
 
std::string get_fluid_list (void)
 Get a comma-separated-list of fluids that are included.
 
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.
 
std::string vecstring_to_string (const std::vector< std::string > &a)
 Templates for turning vectors (1D-matrices) into strings.
 
void get_dT_drho (HelmholtzEOSMixtureBackend *HEOS, parameters index, CoolPropDbl &dT, CoolPropDbl &drho)
 
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. 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_reducing_function_name (const std::string &CAS1, const std::string &CAS2)
 
DepartureFunctionget_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 ()
 
JSONIncompressibleLibraryget_incompressible_library (void)
 Get a reference to the library instance.
 
IncompressibleFluidget_incompressible_fluid (const std::string &fluid_string)
 Get the fluid structure returned as a reference.
 
std::string get_incompressible_list_pure (void)
 Return a comma-separated list of incompressible pure fluid names.
 
std::string get_incompressible_list_solution (void)
 Return a comma-separated list of solution names.
 
bool force_load_REFPROP ()
 
bool force_unload_REFPROP ()
 
void REFPROP_SETREF (char hrf[3], int ixflag, double x0[1], double &h0, double &s0, double &T0, double &p0, int &ierr, char herr[255], 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.
 
void set_config_as_json (rapidjson::Value &val)
 
bool has_backend_in_string (const std::string &fluid_string, std::size_t &i)
 
bool has_fractions_in_string (const std::string &fluid_string)
 
bool has_solution_concentration (const std::string &fluid_string)
 
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)
 
const std::string & get_phase_short_desc (phases phase)
 
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 compare_REFPROP_and_CoolProp (const std::string &fluid, CoolProp::input_pairs inputs, double val1, double val2, std::size_t N, double d1, double d2)
 
def get (s)
 
def test ()
 
def get_include_directory ()
 
def copy_BibTeX_library (file=None, folder=None)
 

Variables

const parameter_info parameter_info_list []
 
const phase_info phase_info_list []
 
const input_pair_info input_pair_list []
 
const backend_family_info backend_family_list []
 
const backend_info backend_list []
 

Typedef Documentation

§ mat

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

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} \]

\

Enumeration Type Documentation

§ input_pairs

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

Enumerator
QT_INPUTS 

Molar quality, Temperature in K.

PQ_INPUTS 

Pressure in Pa, Molar quality.

QSmolar_INPUTS 

Molar quality, Entropy in J/mol/K.

QSmass_INPUTS 

Molar quality, Entropy in J/kg/K.

HmolarQ_INPUTS 

Enthalpy in J/mol, Molar quality.

HmassQ_INPUTS 

Enthalpy in J/kg, Molar quality.

DmolarQ_INPUTS 

Density in mol/m^3, Molar quality.

DmassQ_INPUTS 

Density in kg/m^3, Molar 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.

§ parameters


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

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.

iSmolar_residual 

The residual molar entropy (s^r/R = tau*dar_dtau-ar)

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.

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.

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 = p*v/(R*T)

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.

§ phases

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.

§ 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\)

Function Documentation

§ 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
backendThe backend to which these should be added; e.g. "HEOS", "SRK", "PR"
Returns
output Returns true if the fluids were able to be added

§ 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
identifier1The CAS # (or name) for the first fluid
identifier2The CAS # (or name) for the second fluid
ruleThe simple mixing rule to be used ("linear", "Lorentz-Berthelot")

§ BoundedSecant()

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
fA pointer to an instance of the FuncWrapper1D class that implements the call() function
x0The initial guess for the solution
xmaxThe upper bound for the solution
xminThe lower bound for the solution
dxThe initial amount that is added to x in order to build the numerical derivative
tolThe absolute value of the tolerance accepted for the objective function
maxiterMaximum number of iterations
Returns
If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

§ Brent()

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
fA pointer to an instance of the FuncWrapper1D class that must implement the class() function
aThe minimum bound for the solution of f=0
bThe maximum bound for the solution of f=0
machepsThe machine precision
tTolerance (absolute)
maxiterMaximum number of steps allowed. Will throw a SolutionError if the solution cannot be found

§ config_string_to_key()

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

Convert a string description to a configuration key.

Go from string to enum key.

§ copy_BibTeX_library()

def CoolProp.copy_BibTeX_library (   file = None,
  folder = None 
)
Copy the CoolProp BibTeX library file to the file given by ``file``, or the folder given by ``folder``

If no inputs are provided, the file will be copied to the current working 
directory

Parameters
----------
file : string
    Provide if you want to put the file into a given file
folder : string
    Provide if you want to put the CoolPropBibTeXLibrary.bib file into the given folder

§ 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
coefficientsmatrix containing the ordered coefficients

§ 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
coefficientsmatrix containing the ordered coefficients
axisaxis along which to extract

§ 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_stringThe input string
backendThe output backend, if none found, "?"
fluidThe output fluid string (minus the backend string)

§ 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_stringThe input string
fractionsThe fractions
Returns
The fluids, as a '&' delimited string

§ generate_update_pair()

template<class T >
CoolProp::input_pairs CoolProp::generate_update_pair ( parameters  key1,
value1,
parameters  key2,
value2,
T &  out1,
T &  out2 
)
throw (
)

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
key1The first input key
value1The first input value
key2The second input key
value2The second input value
out1The first output value
out2The second output value
Returns
pair, or INPUT_PAIR_INVALID if not valid

< Molar quality, Temperature in K

< Pressure in Pa, Molar 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

§ get()

def CoolProp.get (   s)
This is just a shorthand function for getting a parameter from
``CoolProp.get_global_param_string``

§ get_config_bool()

bool CoolProp::get_config_bool ( configuration_keys  key)


GETTERS


Return the value of a boolean key from the configuration

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

§ get_csv_parameter_list()

std::string CoolProp::get_csv_parameter_list ( )

Get a comma separated list of parameters.

Return a list of parameters.

§ get_csv_predefined_mixtures()

std::string CoolProp::get_csv_predefined_mixtures ( )

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

§ get_debug_level()

int CoolProp::get_debug_level ( void  )

Get the debug level.

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

§ get_departure_function()

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

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

Parameters
NameThe 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

§ 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
FluidNameThe name of the fluid that is part of CoolProp, for instance "n-Propane"
ParamNameA 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

§ get_global_param_string()

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

Get a globally-defined string.

Parameters
ParamNameA 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

§ get_include_directory()

def CoolProp.get_include_directory ( )
Get the include directory for CoolProp header files that are needed if you want
to compile anything else that uses the CoolProp Cython extension type

Returns
-------
include_directory: The path to the include folder for CoolProp

§ get_mixture_binary_pair_data()

std::string CoolProp::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.

§ get_parameter_information()

std::string CoolProp::get_parameter_information ( int  key,
const std::string &  info 
)

Return information about the parameter.

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

§ Halley()

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
fA pointer to an instance of the FuncWrapper1DWithTwoDerivs class that implements the call() and two derivatives
x0The initial guess for the solution
ftolThe absolute value of the tolerance accepted for the objective function
maxiterMaximum number of iterations
xtol_relThe minimum allowable (relative) step size
Returns
If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

§ Householder4()

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
fA pointer to an instance of the FuncWrapper1DWithThreeDerivs class that implements the call() and three derivatives
x0The initial guess for the solution
ftolThe absolute value of the tolerance accepted for the objective function
maxiterMaximum number of iterations
xtol_relThe minimum allowable (relative) step size
Returns
If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

§ 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

§ 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

§ 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

§ 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

§ 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_nameThe phase name string to be checked ("phase_liquid" for instance)
iOutputGets updated with the phases enum value if phase_name is found

§ 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

§ 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

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

§ 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
fA pointer to an subclass of the FuncWrapperND class that implements the call() and Jacobian() functions
x0The initial guess value for the solution
tolThe root-sum-square of the errors from each of the components
maxiterThe maximum number of iterations
errstringA string with the returned error. If the length of errstring is zero, no errors were found
wA 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

§ Newton()

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
fA pointer to an instance of the FuncWrapper1D class that implements the call() function
x0The initial guess for the solution
ftolThe absolute value of the tolerance accepted for the objective function
maxiterMaximum number of iterations
Returns
If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

§ 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
PhaseThe 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

< 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

§ 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
Name1The first state variable name, one of "T","D","H",etc.
Prop1The first state variable value
Name2The second state variable name, one of "T","D","H",etc.
Prop2The second state variable value
FluidNameThe fluid name
Note
Returns empty string if there was an error; use get_global_param_string("errstring") to retrieve the error

§ 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
FluidNameThe fluid name
OutputThe output parameter, one of "Tcrit","D","H",etc.

§ 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
OutputThe output parameter, one of "T","D","H",etc.
Name1The first state variable name, one of "T","D","H",etc.
Prop1The first state variable value
Name2The second state variable name, one of "T","D","H",etc.
Prop2The second state variable value
FluidNameThe fluid name

§ 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
OutputsA vector of strings for the output parameters
Name1The name of the first input variable
Prop1A vector of the first input values
Name2The name of the second input variable
Prop2A vector of the second input values
backendThe string representation of the backend (HEOS, REFPROP, INCOMP, etc.)
fluidsThe fluid name(s)
fractionsThe fractions (molar, mass, volume, etc.) of the components

§ removeRow()

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.

§ Secant()

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
fA pointer to an instance of the FuncWrapper1D class that implements the call() function
x0The initial guess for the solutionh
dxThe initial amount that is added to x in order to build the numerical derivative
tolThe absolute value of the tolerance accepted for the objective function
maxiterMaximum number of iterations
Returns
If no errors are found, the solution, otherwise the value _HUGE, the value for infinity

§ set_config_bool()

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


SETTERS


Set the value of a boolean configuration value

§ set_debug_level()

void CoolProp::set_debug_level ( int  level)

Set the debug level.

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

§ 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_dataThe 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

§ set_error_string()

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

Set the global error string.

Parameters
errorThe error string to use

§ 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
CAS1The CAS # for the first fluid (order matters!)
CAS2The CAS # for the second fluid (order matters!)
paramThe parameter you want to set
valThe value of the parameter
Returns
None

§ 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
FluidNameThe name of the fluid
TTemperature at reference state [K]
rhomolarMolar density at reference state [mol/m^3]
hmolar0Molar enthalpy at reference state [J/mol]
smolar0Molar entropy at reference state [J/mol/K]

§ 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
FluidNameThe name of the fluid (Backend can be provided like "REFPROP::Water", or if no backend is provided, "HEOS" is the assumed backend)
reference_stateThe 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} \)

§ set_warning_string()

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

An internal function to set the global warning string.

Parameters
warningThe string to set as the warning string

§ test()

def CoolProp.test ( )
Run the tests in the test folder

§ 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
coefficientsmatrix containing the ordered coefficients

§ 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
coefficientsmatrix containing the ordered coefficients
axisaxis along which to extract data

§ vec_to_eigen() [3/3]

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

Variable Documentation

§ backend_family_list

const 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" }
}

§ backend_list

const 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 }
}

§ 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", "" },
}
Supercritical liquid (p > pc, T < Tc)
Definition: DataStructures.h:159
Subcritical liquid.
Definition: DataStructures.h:156
Supercritical gas (p < pc, T > Tc)
Definition: DataStructures.h:158
Unknown phase.
Definition: DataStructures.h:163
At the critical point.
Definition: DataStructures.h:160
Subcritical gas.
Definition: DataStructures.h:161
Twophase.
Definition: DataStructures.h:162
Supercritical (p > pc, T > Tc)
Definition: DataStructures.h:157