DataStructures.h

Go to the documentation of this file.

/*
 * DataStructures.h
 *
 *  Created on: 21 Dec 2013
 *      Author: jowr
 */
 
#ifndef DATASTRUCTURES_H_
#define DATASTRUCTURES_H_
 
#include "CoolProp/numerics/numerics.h"
#include "CoolProp/Exceptions.h"
#include <string_view>
namespace CoolProp {
 
struct SimpleState
{
    double rhomolar, T, p, hmolar, smolar, umolar, Q;
    SimpleState() {
        fill(_HUGE);
    }
    void fill(double v) {
        rhomolar = v;
        T = v;
        p = v;
        hmolar = v;
        smolar = v;
        umolar = v;
        Q = v;
    }
    bool is_valid() {
        return ValidNumber(rhomolar) && ValidNumber(T) && ValidNumber(hmolar) && ValidNumber(p);
    }
};
 
struct CriticalState : SimpleState
{
    bool stable;
    CriticalState() : stable(false) {
        fill(_HUGE);
    }
};
 
struct SsatSimpleState : public SimpleState
{
    enum SsatSimpleStateEnum
    {
        SSAT_MAX_NOT_SET = 0,
        SSAT_MAX_DOESNT_EXIST,
        SSAT_MAX_DOES_EXIST
    };
    SsatSimpleStateEnum exists;
    SsatSimpleState() : exists(SSAT_MAX_NOT_SET) {}
};
 
//
// !! If you add a parameter, update the map in the corresponding CPP file !!
enum parameters : int
{
    INVALID_PARAMETER = 0,
 
    // General parameters
    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,      
 
    // Bulk properties
    iT,      
    iP,      
    iQ,      
    iQmass,  
    iTau,    
    iDelta,  
 
    // Molar specific thermodynamic properties
    iDmolar,           
    iHmolar,           
    iSmolar,           
    iCpmolar,          
    iCp0molar,         
    iCvmolar,          
    iUmolar,           
    iGmolar,           
    iHelmholtzmolar,   
    iHmolar_residual,  
    iSmolar_residual,  
    iGmolar_residual,  
    iHmolar_idealgas,  
    iSmolar_idealgas,  
    iUmolar_idealgas,  
 
    // Mass specific thermodynamic properties
    iDmass,           
    iHmass,           
    iSmass,           
    iCpmass,          
    iCp0mass,         
    iCvmass,          
    iUmass,           
    iGmass,           
    iHelmholtzmass,   
    iHmass_idealgas,  
    iSmass_idealgas,  
    iUmass_idealgas,  
 
    // Transport properties
    iviscosity,        
    iconductivity,     
    isurface_tension,  
    iPrandtl,          
 
    // Derivative-based terms
    ispeed_sound,                       
    iisothermal_compressibility,        
    iisobaric_expansion_coefficient,    
    iisentropic_expansion_coefficient,  
 
    // Fundamental derivative of gas dynamics
    ifundamental_derivative_of_gas_dynamics,  
 
    // Derivatives of the residual non-dimensionalized Helmholtz energy with respect to the EOS variables
    ialphar,
    idalphar_dtau_constdelta,
    idalphar_ddelta_consttau,
 
    // Derivatives of the ideal-gas non-dimensionalized Helmholtz energy with respect to the EOS variables
    ialpha0,
    idalpha0_dtau_constdelta,
    idalpha0_ddelta_consttau,
    id2alpha0_ddelta2_consttau,
    id3alpha0_ddelta3_consttau,
 
    // Other functions and derivatives
    iBvirial,      
    iCvirial,      
    idBvirial_dT,  
    idCvirial_dT,  
    iZ,            
    iPIP,          
 
    // Accessors for incompressibles
    ifraction_min,  
    ifraction_max,  
    iT_freeze,      
 
    // Environmental parameters
    iGWP20,               
    iGWP100,              
    iGWP500,              
    iFH,                  
    iHH,                  
    iPH,                  
    iODP,                 
    iPhase,               
    iundefined_parameter  
 
};
// !! If you add a parameter, update the map in the corresponding CPP file !!
// !! Also update phase_lookup_string() in CoolProp.cpp                    !!
 
enum phases : int
{
    iphase_liquid,                
    iphase_supercritical,         
    iphase_supercritical_gas,     
    iphase_supercritical_liquid,  
    iphase_critical_point,        
    iphase_gas,                   
    iphase_twophase,              
    iphase_unknown,               
    iphase_not_imposed
};  
 
enum fast_evaluate_status : int
{
    fast_evaluate_ok = 0,
    fast_evaluate_out_of_range = 1,
    fast_evaluate_two_phase_disallowed = 2,
    fast_evaluate_unsupported_input = 3,
    fast_evaluate_unsupported_output = 4,
    fast_evaluate_internal_error = 5
};
 
enum schemes
{
    i1,
    i2a,
    i2b,
    i3a,
    i3b,
    i4a,
    i4b,
    i4c
};
 
[[nodiscard]] std::string get_parameter_information(int key, std::string_view info);
 
[[nodiscard]] parameters get_parameter_index(const std::string& param_name);
 
bool is_valid_phase(const std::string& phase_name, phases& iOutput);
 
phases get_phase_index(const std::string& param_name);
 
bool is_valid_scheme(const std::string& scheme_name, schemes& iOutput);
 
schemes get_scheme_index(const std::string& scheme_name);
 
bool is_trivial_parameter(int key);
 
bool is_valid_parameter(const std::string& name, parameters& iOutput);
 
bool is_valid_first_derivative(const std::string& name, parameters& iOf, parameters& iWrt, parameters& iConstant);
 
bool is_valid_first_saturation_derivative(const std::string& name, parameters& iOf, parameters& iWrt);
 
bool is_valid_second_derivative(const std::string& name, parameters& iOf1, parameters& iWrt1, parameters& iConstant1, parameters& iWrt2,
                                parameters& iConstant2);
 
std::string get_csv_parameter_list();
 
enum composition_types
{
    IFRAC_MASS,
    IFRAC_MOLE,
    IFRAC_VOLUME,
    IFRAC_UNDEFINED,
    IFRAC_PURE
};
 
enum fluid_types
{
    FLUID_TYPE_PURE,
    FLUID_TYPE_PSEUDOPURE,
    FLUID_TYPE_REFPROP,
    FLUID_TYPE_INCOMPRESSIBLE_LIQUID,
    FLUID_TYPE_INCOMPRESSIBLE_SOLUTION,
    FLUID_TYPE_UNDEFINED
};
 
// !! If you add a parameter, update the map in the corresponding CPP file !!
enum input_pairs : int
{
    INPUT_PAIR_INVALID = 0,  // Default (invalid) value
    QT_INPUTS,               
    QmassT_INPUTS,           
    PQ_INPUTS,               
    PQmass_INPUTS,           
    QSmolar_INPUTS,          
    QmassSmolar_INPUTS,      
    QSmass_INPUTS,           
    QmassSmass_INPUTS,       
    HmolarQ_INPUTS,          
    HmolarQmass_INPUTS,      
    HmassQ_INPUTS,           
    HmassQmass_INPUTS,       
    DmolarQ_INPUTS,          
    DmolarQmass_INPUTS,      
    DmassQ_INPUTS,           
    DmassQmass_INPUTS,       
 
    PT_INPUTS,  
 
    DmassT_INPUTS,   
    DmolarT_INPUTS,  
    HmolarT_INPUTS,  
    HmassT_INPUTS,   
    SmolarT_INPUTS,  
    SmassT_INPUTS,   
    TUmolar_INPUTS,  
    TUmass_INPUTS,   
 
    DmassP_INPUTS,   
    DmolarP_INPUTS,  
    HmassP_INPUTS,   
    HmolarP_INPUTS,  
    PSmass_INPUTS,   
    PSmolar_INPUTS,  
    PUmass_INPUTS,   
    PUmolar_INPUTS,  
 
    HmassSmass_INPUTS,    
    HmolarSmolar_INPUTS,  
    SmassUmass_INPUTS,    
    SmolarUmolar_INPUTS,  
 
    DmassHmass_INPUTS,    
    DmolarHmolar_INPUTS,  
    DmassSmass_INPUTS,    
    DmolarSmolar_INPUTS,  
    DmassUmass_INPUTS,    
    DmolarUmolar_INPUTS,  
};
// !! If you add or remove a parameter, update the map in the corresponding CPP file !!
 
inline bool match_pair(parameters key1, parameters key2, parameters x1, parameters x2, bool& swap) {
    swap = !(key1 == x1);
    return ((key1 == x1 && key2 == x2) || (key2 == x1 && key1 == x2));
};
 
inline bool is_Qmass_pair(input_pairs p) {
    switch (p) {
        case QmassT_INPUTS:
        case PQmass_INPUTS:
        case QmassSmolar_INPUTS:
        case QmassSmass_INPUTS:
        case HmolarQmass_INPUTS:
        case HmassQmass_INPUTS:
        case DmolarQmass_INPUTS:
        case DmassQmass_INPUTS:
            return true;
        default:
            return false;
    }
}
template <class T>
[[nodiscard]] CoolProp::input_pairs generate_update_pair(parameters key1, const T& value1, parameters key2, const T& value2, T& out1,
                                                         T& out2) noexcept {
    CoolProp::input_pairs pair;
    bool swap;
 
    if (match_pair(key1, key2, iQ, iT, swap)) {
        pair = QT_INPUTS;  
    } else if (match_pair(key1, key2, iQmass, iT, swap)) {
        pair = QmassT_INPUTS;  
    } else if (match_pair(key1, key2, iP, iQ, swap)) {
        pair = PQ_INPUTS;  
    } else if (match_pair(key1, key2, iP, iQmass, swap)) {
        pair = PQmass_INPUTS;  
    } else if (match_pair(key1, key2, iP, iT, swap)) {
        pair = PT_INPUTS;  
    } else if (match_pair(key1, key2, iDmolar, iT, swap)) {
        pair = DmolarT_INPUTS;  // Molar density in mol/m^3, Temperature in K
    } else if (match_pair(key1, key2, iDmass, iT, swap)) {
        pair = DmassT_INPUTS;  // Mass density in kg/m^3, Temperature in K
    } else if (match_pair(key1, key2, iHmolar, iT, swap)) {
        pair = HmolarT_INPUTS;  // Enthalpy in J/mol, Temperature in K
    } else if (match_pair(key1, key2, iHmass, iT, swap)) {
        pair = HmassT_INPUTS;  // Enthalpy in J/kg, Temperature in K
    } else if (match_pair(key1, key2, iSmolar, iT, swap)) {
        pair = SmolarT_INPUTS;  // Entropy in J/mol/K, Temperature in K
    } else if (match_pair(key1, key2, iSmass, iT, swap)) {
        pair = SmassT_INPUTS;  // Entropy in J/kg/K, Temperature in K
    } else if (match_pair(key1, key2, iT, iUmolar, swap)) {
        pair = TUmolar_INPUTS;  // Temperature in K, Internal energy in J/mol
    } else if (match_pair(key1, key2, iT, iUmass, swap)) {
        pair = TUmass_INPUTS;  // Temperature in K, Internal energy in J/kg
    } else if (match_pair(key1, key2, iDmass, iHmass, swap)) {
        pair = DmassHmass_INPUTS;  // Mass density in kg/m^3, Enthalpy in J/kg
    } else if (match_pair(key1, key2, iDmolar, iHmolar, swap)) {
        pair = DmolarHmolar_INPUTS;  // Molar density in mol/m^3, Enthalpy in J/mol
    } else if (match_pair(key1, key2, iDmass, iSmass, swap)) {
        pair = DmassSmass_INPUTS;  // Mass density in kg/m^3, Entropy in J/kg/K
    } else if (match_pair(key1, key2, iDmolar, iSmolar, swap)) {
        pair = DmolarSmolar_INPUTS;  // Molar density in mol/m^3, Entropy in J/mol/K
    } else if (match_pair(key1, key2, iDmass, iUmass, swap)) {
        pair = DmassUmass_INPUTS;  // Mass density in kg/m^3, Internal energy in J/kg
    } else if (match_pair(key1, key2, iDmolar, iUmolar, swap)) {
        pair = DmolarUmolar_INPUTS;  // Molar density in mol/m^3, Internal energy in J/mol
    } else if (match_pair(key1, key2, iDmass, iP, swap)) {
        pair = DmassP_INPUTS;  // Mass density in kg/m^3, Pressure in Pa
    } else if (match_pair(key1, key2, iDmolar, iP, swap)) {
        pair = DmolarP_INPUTS;  // Molar density in mol/m^3, Pressure in Pa
    } else if (match_pair(key1, key2, iDmass, iQ, swap)) {
        pair = DmassQ_INPUTS;  // Mass density in kg/m^3, molar vapor quality
    } else if (match_pair(key1, key2, iDmass, iQmass, swap)) {
        pair = DmassQmass_INPUTS;  // Mass density in kg/m^3, mass-basis vapor quality
    } else if (match_pair(key1, key2, iDmolar, iQ, swap)) {
        pair = DmolarQ_INPUTS;  // Molar density in mol/m^3, molar vapor quality
    } else if (match_pair(key1, key2, iDmolar, iQmass, swap)) {
        pair = DmolarQmass_INPUTS;  // Molar density in mol/m^3, mass-basis vapor quality
    } else if (match_pair(key1, key2, iHmass, iP, swap)) {
        pair = HmassP_INPUTS;  // Enthalpy in J/kg, Pressure in Pa
    } else if (match_pair(key1, key2, iHmolar, iP, swap)) {
        pair = HmolarP_INPUTS;  // Enthalpy in J/mol, Pressure in Pa
    } else if (match_pair(key1, key2, iP, iSmass, swap)) {
        pair = PSmass_INPUTS;  // Pressure in Pa, Entropy in J/kg/K
    } else if (match_pair(key1, key2, iP, iSmolar, swap)) {
        pair = PSmolar_INPUTS;  // Pressure in Pa, Entropy in J/mol/K
    } else if (match_pair(key1, key2, iP, iUmass, swap)) {
        pair = PUmass_INPUTS;  // Pressure in Pa, Internal energy in J/kg
    } else if (match_pair(key1, key2, iP, iUmolar, swap)) {
        pair = PUmolar_INPUTS;  // Pressure in Pa, Internal energy in J/mol
    } else if (match_pair(key1, key2, iHmass, iSmass, swap)) {
        pair = HmassSmass_INPUTS;  // Enthalpy in J/kg, Entropy in J/kg/K
    } else if (match_pair(key1, key2, iHmolar, iSmolar, swap)) {
        pair = HmolarSmolar_INPUTS;  // Enthalpy in J/mol, Entropy in J/mol/K
    } else if (match_pair(key1, key2, iSmass, iUmass, swap)) {
        pair = SmassUmass_INPUTS;  
    } else if (match_pair(key1, key2, iSmolar, iUmolar, swap)) {
        pair = SmolarUmolar_INPUTS;  
    } else {
        pair = INPUT_PAIR_INVALID;
        return pair;
    }
 
    if (!swap) {
        out1 = value1;
        out2 = value2;
    } else {
        out1 = value2;
        out2 = value1;
    }
    return pair;
};
 
input_pairs get_input_pair_index(const std::string& input_pair_name);
 
const std::string& get_input_pair_short_desc(input_pairs pair);
 
const std::string& get_input_pair_long_desc(input_pairs pair);
 
void split_input_pair(input_pairs pair, parameters& p1, parameters& p2);
 
extern void apply_simple_mixing_rule(const std::string& identifier1, const std::string& identifier2, const std::string& rule);
extern void set_interaction_parameters(const std::string& string_data);
 
extern std::string get_mixture_binary_pair_data(const std::string& CAS1, const std::string& CAS2, const std::string& param);
extern void set_mixture_binary_pair_data(const std::string& CAS1, const std::string& CAS2, const std::string& param, const double val);
extern std::string get_mixture_binary_pair_pcsaft(const std::string& CAS1, const std::string& CAS2, const std::string& param);
extern void set_mixture_binary_pair_pcsaft(const std::string& CAS1, const std::string& CAS2, const std::string& param, const double val);
 
// !! If you add a parameter, update the map in the corresponding CPP file !!
enum backend_families : int
{
    INVALID_BACKEND_FAMILY = 0,
    HEOS_BACKEND_FAMILY,
    REFPROP_BACKEND_FAMILY,
    INCOMP_BACKEND_FAMILY,
    IF97_BACKEND_FAMILY,
    TREND_BACKEND_FAMILY,
    TTSE_BACKEND_FAMILY,
    BICUBIC_BACKEND_FAMILY,
    SRK_BACKEND_FAMILY,
    PR_BACKEND_FAMILY,
    VTPR_BACKEND_FAMILY,
    PCSAFT_BACKEND_FAMILY,
    SVDSBTL_BACKEND_FAMILY
};
enum backends : int
{
    INVALID_BACKEND = 0,
    HEOS_BACKEND_PURE,
    HEOS_BACKEND_MIX,
    REFPROP_BACKEND_PURE,
    REFPROP_BACKEND_MIX,
    INCOMP_BACKEND,
    IF97_BACKEND,
    TREND_BACKEND,
    TTSE_BACKEND,
    BICUBIC_BACKEND,
    SRK_BACKEND,
    PR_BACKEND,
    VTPR_BACKEND,
    PCSAFT_BACKEND,
    SVDSBTL_BACKEND
};
 
void extract_backend_families(const std::string& backend_string, backend_families& f1, backend_families& f2);
void extract_backend_families_string(std::string backend_string, backend_families& f1, std::string& f2);
std::string get_backend_string(backends backend);
 
#if !defined(NO_FMTLIB) && FMT_VERSION >= 90000
inline int format_as(parameters parameter) {
    return fmt::underlying(parameter);
}
 
inline int format_as(phases phase) {
    return fmt::underlying(phase);
}
 
inline int format_as(schemes scheme) {
    return fmt::underlying(scheme);
}
 
inline int format_as(composition_types type) {
    return fmt::underlying(type);
}
 
inline int format_as(fluid_types type) {
    return fmt::underlying(type);
}
 
inline int format_as(input_pairs pair) {
    return fmt::underlying(pair);
}
 
inline int format_as(backend_families family) {
    return fmt::underlying(family);
}
 
inline int format_as(backends backend) {
    return fmt::underlying(backend);
}
#endif
 
} /* namespace CoolProp */
#endif /* DATASTRUCTURES_H_ */