CoolProp
|
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 | IdealHelmholtzGERG2004Cosh |
class | IdealHelmholtzGERG2004Sinh |
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 | 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 |
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 | 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 |
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 | 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 |
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< DepartureFunction > | DepartureFunctionPointer |
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, iHmolar_residual, iSmolar_residual, iGmolar_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, 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 } |
Define some constants that will be used throughoutThese 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 | schemes { i1, i2a, i2b, i3a, i3b, i4a, i4b, i4c } |
Constants for the different PC-SAFT association schemes (see Huang and Radosz 1990) | |
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, PCSAFT_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, PCSAFT_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... | |
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... | |
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 ¶m_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 ¶m_name) |
Return the enum key corresponding to the phase name ("phase_liquid" for instance) | |
bool | is_valid_scheme (const std::string &scheme_name, schemes &iOutput) |
Return true if passed PC-SAFT association scheme name is valid, otherwise false. More... | |
schemes | get_scheme_index (const std::string &scheme_name) |
Return the enum key corresponding to the association scheme name ("2B" 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 ¶m) |
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 ¶m, const double val) |
Set a parameter for the given binary pair. More... | |
std::string | get_mixture_binary_pair_pcsaft (const std::string &CAS1, const std::string &CAS2, const std::string ¶m) |
void | set_mixture_binary_pair_pcsaft (const std::string &CAS1, const std::string &CAS2, const std::string ¶m, const double val) |
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 > | |
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) |
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 | ExtrapolatingSecant (FuncWrapper1D *f, double x0, 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 | 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) |
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) |
BackendLibrary & | get_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 () |
JSONFluidLibrary & | get_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 | 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_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 (void) |
Get a reference to the library instance. | |
IncompressibleFluid & | get_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 ¶m, 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 ParameterInformation & | get_parameter_information () |
const PhaseInformation & | get_phase_information () |
const std::string & | get_phase_short_desc (phases phase) |
const SchemeInformation & | get_scheme_information () |
const std::string & | get_scheme_short_desc (schemes scheme) |
const InputPairInformation & | get_input_pair_information () |
const BackendInformation & | get_backend_information () |
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 [] |
ParameterInformation * | parameter_information_p = nullptr |
const phase_info | phase_info_list [] |
PhaseInformation * | phase_information_p = nullptr |
const scheme_info | scheme_info_list [] |
SchemeInformation * | scheme_information_p = nullptr |
const input_pair_info | input_pair_list [] |
InputPairInformation * | input_pair_information_p = nullptr |
const backend_family_info | backend_family_list [] |
const backend_info | backend_list [] |
BackendInformation * | backend_information_p = nullptr |
constexpr double | CPPOLY_EPSILON = DBL_EPSILON * 100.0 |
constexpr double | CPPOLY_DELTA = CPPOLY_EPSILON * 10.0 |
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} \]
\
These are input pairs that can be used for the update function (in each pair, input keys are sorted alphabetically)
enum CoolProp::parameters |
enum CoolProp::phases |
These are constants for the phases of the fluid.
bool CoolProp::add_fluids_as_JSON | ( | const std::string & | backend, |
const std::string & | fluidstring | ||
) |
Add fluids as a JSON-formatted string.
backend | The backend to which these should be added; e.g. "HEOS", "SRK", "PR" |
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.
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") |
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.
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 |
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].
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 |
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.
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
std::vector<std::vector<T> > CoolProp::eigen_to_vec | ( | const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > & | coefficients | ) |
coefficients | matrix containing the ordered coefficients |
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.
coefficients | matrix containing the ordered coefficients |
axis | axis along which to extract |
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 "?"
fluid_string | The input string |
backend | The output backend, if none found, "?" |
fluid | The output fluid string (minus the backend string) |
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.
fluid_string | The input string |
fractions | The fractions |
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.
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 |
CoolProp::input_pairs CoolProp::generate_update_pair | ( | parameters | key1, |
T | value1, | ||
parameters | key2, | ||
T | 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
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 |
< 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
def CoolProp.get | ( | s | ) |
This is just a shorthand function for getting a parameter from ``CoolProp.get_global_param_string``
bool CoolProp::get_config_bool | ( | configuration_keys | key | ) |
GETTERS
Return the value of a boolean key from the configuration
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)
std::string CoolProp::get_csv_parameter_list | ( | ) |
Get a comma separated list of parameters.
Return a list of parameters.
std::string CoolProp::get_csv_predefined_mixtures | ( | ) |
Get a comma-separated list of predefined mixtures in CoolProp.
int CoolProp::get_debug_level | ( | void | ) |
Get the debug level.
DepartureFunction * CoolProp::get_departure_function | ( | const std::string & | Name | ) |
Get the allocated Departure function for a given departure function name.
Name | The name of the function to be used, or its alias |
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)
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 |
std::string CoolProp::get_global_param_string | ( | const std::string & | ParamName | ) |
Get a globally-defined string.
ParamName | A string, one of "version", "errstring", "warnstring", "gitrevision", "FluidsList", "fluids_list", "parameter_list","predefined_mixtures" |
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
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.
std::string CoolProp::get_parameter_information | ( | int | key, |
const std::string & | info | ||
) |
Return information about the parameter.
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" |
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
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 |
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
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 |
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
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
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
bool CoolProp::is_valid_fluid_string | ( | const std::string & | fluidstring | ) |
Check if the fluid name is valid.
bool CoolProp::is_valid_phase | ( | const std::string & | phase_name, |
phases & | iOutput | ||
) |
Return true if passed phase name is valid, otherwise false.
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 |
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.
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 |
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
void CoolProp::load_table | ( | T & | table, |
const std::string & | path_to_tables, | ||
const std::string & | filename | ||
) |
table | |
path_to_tables | |
filename |
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.
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
f | A pointer to an subclass of the FuncWrapperND class that implements the call() and Jacobian() functions |
x0 | 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 |
errstring | A string with the returned error. If the length of errstring is zero, no errors were found |
w | A relaxation multiplier on the step size, multiplying the normal step size |
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.
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 |
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.
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
< 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
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.
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 |
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)
FluidName | The fluid name |
Output | The output parameter, one of "Tcrit","D","H",etc. |
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)
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 |
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.
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 |
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
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 |
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.
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.
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 |
void CoolProp::set_config_bool | ( | configuration_keys | key, |
bool | val | ||
) |
SETTERS
Set the value of a boolean configuration value
void CoolProp::set_debug_level | ( | int | level | ) |
Set the debug level.
level | The level of the verbosity for the debugging output (0-10) 0: no debgging output |
void CoolProp::set_departure_functions | ( | const std::string & | string_data | ) |
Set the departure functions in the departure function library from a string format.
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 |
void CoolProp::set_error_string | ( | const std::string & | error | ) |
Set the global error string.
error | The error string to use |
void CoolProp::set_interaction_parameters | ( | const std::string & | string_data | ) |
Set the interaction parameters from a string format.
string_data | The model parameters, as a JSON-formatted string |
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.
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 |
void CoolProp::set_predefined_mixtures | ( | const std::string & | string_data | ) |
Set predefined mixtures at runtime.
string_data | The predefined mixtures, as a JSON-formatted string |
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.
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] |
void CoolProp::set_reference_stateS | ( | const std::string & | FluidName, |
const std::string & | reference_state | ||
) |
Set the reference state based on a string representation.
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} \)
void CoolProp::set_warning_string | ( | const std::string & | warning | ) |
An internal function to set the global warning string.
warning | The string to set as the warning string |
def CoolProp.test | ( | ) |
Run the tests in the test folder
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> CoolProp::vec_to_eigen | ( | const std::vector< std::vector< T >> & | coefficients | ) |
coefficients | matrix containing the ordered coefficients |
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> CoolProp::vec_to_eigen | ( | const std::vector< T > & | coefficients, |
int | axis = 0 |
||
) |
coefficients | matrix containing the ordered coefficients |
axis | axis along which to extract data |
Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> CoolProp::vec_to_eigen | ( | const T & | coefficient | ) |
coefficient |
const backend_family_info CoolProp::backend_family_list[] |
const backend_info CoolProp::backend_list[] |
const phase_info CoolProp::phase_info_list[] |
const scheme_info CoolProp::scheme_info_list[] |