From 94bcee472f4cc9a2f2160cfae4d46cbbee64efdd Mon Sep 17 00:00:00 2001 From: Jorrit Wronski Date: Fri, 10 Jun 2016 12:19:18 +0200 Subject: [PATCH] introduced backend enumerations, I hope this fixes #1120 reliably --- include/DataStructures.h | 35 +++++++++ src/AbstractState.cpp | 32 ++++---- src/Backends/Cubics/CubicBackend.h | 4 +- src/Backends/Helmholtz/HelmholtzEOSBackend.h | 3 +- .../Helmholtz/HelmholtzEOSMixtureBackend.h | 3 +- src/Backends/IF97/IF97Backend.h | 2 +- .../Incompressible/IncompressibleBackend.h | 2 +- src/Backends/REFPROP/REFPROPBackend.h | 3 +- src/Backends/REFPROP/REFPROPMixtureBackend.h | 3 +- src/Backends/Tabular/BicubicBackend.cpp | 1 + src/Backends/Tabular/BicubicBackend.h | 3 +- src/Backends/Tabular/TTSEBackend.h | 3 +- src/DataStructures.cpp | 78 ++++++++++++++++++- 13 files changed, 148 insertions(+), 24 deletions(-) diff --git a/include/DataStructures.h b/include/DataStructures.h index 4ccc4114..71c5ceb7 100644 --- a/include/DataStructures.h +++ b/include/DataStructures.h @@ -393,5 +393,40 @@ void split_input_pair(input_pairs pair, parameters &p1, parameters &p2); extern std::string get_mixture_binary_pair_data(const std::string &CAS1, const std::string &CAS2, const std::string ¶m); extern void set_mixture_binary_pair_data(const std::string &CAS1, const std::string &CAS2, const std::string ¶m, const double val); + +/// The structure is taken directly from the AbstractState class. +// !! If you add a parameter, update the map in the corresponding CPP file !! +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 +}; +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 +}; + +/// Convert a string into the enum values +void extract_backend_enums(std::string backend_string, backend_families &f1, backend_families &f2); +void extract_backend_enums_string(std::string backend_string, backend_families &f1, std::string &f2); +std::string get_backend_string(backends backend); + } /* namespace CoolProp */ #endif /* DATASTRUCTURES_H_ */ diff --git a/src/AbstractState.cpp b/src/AbstractState.cpp index 2438411f..a3d7c352 100644 --- a/src/AbstractState.cpp +++ b/src/AbstractState.cpp @@ -12,6 +12,7 @@ #include #include "math.h" #include "AbstractState.h" +#include "DataStructures.h" #include "Backends/REFPROP/REFPROPBackend.h" #include "Backends/Helmholtz/HelmholtzEOSBackend.h" #include "Backends/Incompressible/IncompressibleBackend.h" @@ -31,8 +32,11 @@ AbstractState * AbstractState::factory(const std::string &backend, const std::ve if (get_debug_level() > 0){ std::cout << "AbstractState::factory(" << backend << "," << stringvec_to_string(fluid_names) << ")" << std::endl; } - static const std::string HEOS_string = "HEOS"; - if (!backend.compare(HEOS_string) || !backend.compare("HelmholtzEOSBackend") || !backend.compare("HelmholtzEOSMixtureBackend")) + + backend_families f1; + std::string f2; + extract_backend_enums_string(backend, f1, f2); + if (f1==HEOS_BACKEND_FAMILY) { if (fluid_names.size() == 1){ return new HelmholtzEOSBackend(fluid_names[0]); @@ -41,7 +45,7 @@ AbstractState * AbstractState::factory(const std::string &backend, const std::ve return new HelmholtzEOSMixtureBackend(fluid_names); } } - else if (!backend.compare("REFPROP") || !backend.compare("REFPROPBackend") || !backend.compare("REFPROPMixtureBackend")) + else if (f1==REFPROP_BACKEND_FAMILY) { if (fluid_names.size() == 1){ return new REFPROPBackend(fluid_names[0]); @@ -50,37 +54,39 @@ AbstractState * AbstractState::factory(const std::string &backend, const std::ve return new REFPROPMixtureBackend(fluid_names); } } - else if (!backend.compare("INCOMP") || !backend.compare("IncompressibleBackend")) + else if (f1==INCOMP_BACKEND_FAMILY) { if (fluid_names.size() != 1){throw ValueError(format("For INCOMP backend, name vector must be one element long"));} return new IncompressibleBackend(fluid_names[0]); } - else if (!backend.compare("IF97") || !backend.compare("IF97Backend")) + else if (f1==IF97_BACKEND_FAMILY) { return new IF97Backend(); } #if !defined(NO_TABULAR_BACKENDS) - else if (backend.find("TTSE&") == 0 || backend.find("TTSEBackend&") == 0) + else if (f1==TTSE_BACKEND_FAMILY) { // Will throw if there is a problem with this backend - shared_ptr AS(factory(backend.substr(5), fluid_names)); + shared_ptr AS(factory(f2, fluid_names)); return new TTSEBackend(AS); } - else if (backend.find("BICUBIC&") == 0 || backend.find("BicubicBackend&") == 0) + else if (f1==BICUBIC_BACKEND_FAMILY) { // Will throw if there is a problem with this backend - shared_ptr AS(factory(backend.substr(8), fluid_names)); + shared_ptr AS(factory(f2, fluid_names)); return new BicubicBackend(AS); } #endif - else if (!backend.compare("TREND")) + else if (f1==TREND_BACKEND_FAMILY) { throw ValueError("TREND backend not yet implemented"); } - else if (backend == "SRK" || backend == "SRKBackend") { + else if (f1 == SRK_BACKEND_FAMILY) + { return new SRKBackend(fluid_names, get_config_double(R_U_CODATA)); } - else if (backend == "PR" || backend == "Peng-Robinson" || backend == "PengRobinsonBackend"){ + else if (f1==PR_BACKEND_FAMILY) + { return new PengRobinsonBackend(fluid_names, get_config_double(R_U_CODATA)); } else if (!backend.compare("?") || backend.empty()) @@ -90,7 +96,7 @@ AbstractState * AbstractState::factory(const std::string &backend, const std::ve if (idel == std::string::npos) // No '::' found, no backend specified, try HEOS, otherwise a failure { // Figure out what backend to use - return factory(HEOS_string, fluid_names); + return factory("HEOS", fluid_names); } else { diff --git a/src/Backends/Cubics/CubicBackend.h b/src/Backends/Cubics/CubicBackend.h index e2fed9c7..02bfea5d 100644 --- a/src/Backends/Cubics/CubicBackend.h +++ b/src/Backends/Cubics/CubicBackend.h @@ -215,7 +215,7 @@ public: ACB->copy_k(this); return ACB; } - std::string backend_name(void){return "SRKBackend";} + std::string backend_name(void) { return get_backend_string(SRK_BACKEND); } }; class PengRobinsonBackend : public AbstractCubicBackend { @@ -255,7 +255,7 @@ public: ACB->copy_k(this); return ACB; } - std::string backend_name(void){return "PengRobinsonBackend";} + std::string backend_name(void) { return get_backend_string(PR_BACKEND); } }; /** diff --git a/src/Backends/Helmholtz/HelmholtzEOSBackend.h b/src/Backends/Helmholtz/HelmholtzEOSBackend.h index 93f4648d..5226a2e7 100644 --- a/src/Backends/Helmholtz/HelmholtzEOSBackend.h +++ b/src/Backends/Helmholtz/HelmholtzEOSBackend.h @@ -12,6 +12,7 @@ #include "HelmholtzEOSMixtureBackend.h" #include "Fluids/FluidLibrary.h" #include "MixtureParameters.h" +#include "DataStructures.h" namespace CoolProp { @@ -57,7 +58,7 @@ public: if (get_debug_level() > 0){ std::cout << "successfully set up state" << std::endl; } }; virtual ~HelmholtzEOSBackend(){}; - std::string backend_name(void){return "HelmholtzEOSBackend";} + std::string backend_name(void) { return get_backend_string(HEOS_BACKEND_PURE); } }; } /* namespace CoolProp */ diff --git a/src/Backends/Helmholtz/HelmholtzEOSMixtureBackend.h b/src/Backends/Helmholtz/HelmholtzEOSMixtureBackend.h index 4b15d70e..2d023969 100644 --- a/src/Backends/Helmholtz/HelmholtzEOSMixtureBackend.h +++ b/src/Backends/Helmholtz/HelmholtzEOSMixtureBackend.h @@ -8,6 +8,7 @@ #include "ExcessHEFunction.h" #include "Solvers.h" #include "PhaseEnvelope.h" +#include "DataStructures.h" #include @@ -57,7 +58,7 @@ public: return ptr; }; virtual ~HelmholtzEOSMixtureBackend(){}; - std::string backend_name(void){return "HelmholtzEOSMixtureBackend";} + std::string backend_name(void) { return get_backend_string(HEOS_BACKEND_MIX); } shared_ptr Reducing; shared_ptr residual_helmholtz; PhaseEnvelopeData PhaseEnvelope; diff --git a/src/Backends/IF97/IF97Backend.h b/src/Backends/IF97/IF97Backend.h index add22ff0..93aa61d1 100644 --- a/src/Backends/IF97/IF97Backend.h +++ b/src/Backends/IF97/IF97Backend.h @@ -20,7 +20,7 @@ protected: public: /// The name of the backend being used - std::string backend_name(void){return "IF97Backend";} + std::string backend_name(void) { return get_backend_string(IF97_BACKEND); } // REQUIRED BUT NOT USED IN IF97 FUNCTIONS bool using_mole_fractions(void){return false;}; diff --git a/src/Backends/Incompressible/IncompressibleBackend.h b/src/Backends/Incompressible/IncompressibleBackend.h index 3ffe6c60..89a1b778 100644 --- a/src/Backends/Incompressible/IncompressibleBackend.h +++ b/src/Backends/Incompressible/IncompressibleBackend.h @@ -39,7 +39,7 @@ protected: public: IncompressibleBackend(); virtual ~IncompressibleBackend(){}; - std::string backend_name(void){return "IncompressibleBackend";} + std::string backend_name(void) { return get_backend_string(INCOMP_BACKEND); } /// The instantiator /// @param fluid object, mostly for testing purposes diff --git a/src/Backends/REFPROP/REFPROPBackend.h b/src/Backends/REFPROP/REFPROPBackend.h index 483a09be..ed0b0e16 100644 --- a/src/Backends/REFPROP/REFPROPBackend.h +++ b/src/Backends/REFPROP/REFPROPBackend.h @@ -9,6 +9,7 @@ #define REFPROPBACKEND_H_ #include "REFPROPMixtureBackend.h" +#include "DataStructures.h" namespace CoolProp { @@ -22,7 +23,7 @@ public: REFPROPBackend(); REFPROPBackend(const std::string &fluid_name); - std::string backend_name(void){return "REFPROPBackend";} + std::string backend_name(void) { return get_backend_string(REFPROP_BACKEND_PURE); } virtual ~REFPROPBackend(); }; diff --git a/src/Backends/REFPROP/REFPROPMixtureBackend.h b/src/Backends/REFPROP/REFPROPMixtureBackend.h index 39b3ad02..48402885 100644 --- a/src/Backends/REFPROP/REFPROPMixtureBackend.h +++ b/src/Backends/REFPROP/REFPROPMixtureBackend.h @@ -9,6 +9,7 @@ #define REFPROPMIXTUREBACKEND_H_ #include "AbstractState.h" +#include "DataStructures.h" #include @@ -45,7 +46,7 @@ public: /// A function to actually do the initalization to allow it to be called in derived classes void construct(const std::vector& fluid_names); - std::string backend_name(void){return "REFPROPMixtureBackend";} + std::string backend_name(void) { return get_backend_string(REFPROP_BACKEND_MIX); } virtual ~REFPROPMixtureBackend(); static std::string version(); diff --git a/src/Backends/Tabular/BicubicBackend.cpp b/src/Backends/Tabular/BicubicBackend.cpp index 4db99794..718a89c5 100644 --- a/src/Backends/Tabular/BicubicBackend.cpp +++ b/src/Backends/Tabular/BicubicBackend.cpp @@ -2,6 +2,7 @@ #include "BicubicBackend.h" #include "MatrixMath.h" +#include "DataStructures.h" #include "Backends/Helmholtz/PhaseEnvelopeRoutines.h" void CoolProp::BicubicBackend::find_native_nearest_good_indices(SinglePhaseGriddedTableData &table, const std::vector > &coeffs, double x, double y, std::size_t &i, std::size_t &j) diff --git a/src/Backends/Tabular/BicubicBackend.h b/src/Backends/Tabular/BicubicBackend.h index 023c7793..61b4939d 100644 --- a/src/Backends/Tabular/BicubicBackend.h +++ b/src/Backends/Tabular/BicubicBackend.h @@ -3,6 +3,7 @@ #include "TabularBackends.h" #include "Exceptions.h" +#include "DataStructures.h" #include "Eigen/Core" @@ -89,7 +90,7 @@ class BicubicBackend : public TabularBackend dataset->build_coeffs(single_phase_logph, dataset->coeffs_ph); dataset->build_coeffs(single_phase_logpT, dataset->coeffs_pT); }; - std::string backend_name(void){return "BicubicBackend";} + std::string backend_name(void){return get_backend_string(BICUBIC_BACKEND);} /** * @brief Evaluate a derivative in terms of the native inputs of the table diff --git a/src/Backends/Tabular/TTSEBackend.h b/src/Backends/Tabular/TTSEBackend.h index 6240d661..b9494287 100644 --- a/src/Backends/Tabular/TTSEBackend.h +++ b/src/Backends/Tabular/TTSEBackend.h @@ -2,6 +2,7 @@ #define TTSEBACKEND_H #include "TabularBackends.h" +#include "DataStructures.h" namespace CoolProp { @@ -9,7 +10,7 @@ namespace CoolProp class TTSEBackend : public TabularBackend { public: - std::string backend_name(void){return "TTSEBackend";} + std::string backend_name(void) { return get_backend_string(TTSE_BACKEND); } /// Instantiator; base class loads or makes tables TTSEBackend(shared_ptr AS) : TabularBackend (AS) { imposed_phase_index = iphase_not_imposed; diff --git a/src/DataStructures.cpp b/src/DataStructures.cpp index eedb05cb..050c469d 100644 --- a/src/DataStructures.cpp +++ b/src/DataStructures.cpp @@ -410,7 +410,7 @@ const input_pair_info input_pair_list[] = { { QSmass_INPUTS, "QS_INPUTS", "Molar quality, Entropy in J/kg/K" }, { HmolarQ_INPUTS, "HQ_INPUTS", "Enthalpy in J/mol, Molar quality" }, { HmassQ_INPUTS, "HQ_INPUTS", "Enthalpy in J/kg, Molar quality" }, - { DmassQ_INPUTS, "DmassQ_INPUTS", "Molar density kg/m^3, Molar quality" }, + { DmassQ_INPUTS, "DmassQ_INPUTS", "Molar density kg/m^3, Molar quality" }, { DmolarQ_INPUTS, "DmolarQ_INPUTS", "Molar density in mol/m^3, Molar quality" }, { PQ_INPUTS, "PQ_INPUTS", "Pressure in Pa, Molar quality" }, @@ -529,6 +529,82 @@ void split_input_pair(input_pairs pair, parameters &p1, parameters &p2) } } +const std::map backend_mapping = { + { "", HEOS_BACKEND_FAMILY }, + { "?", HEOS_BACKEND_FAMILY }, + { "HEOS", HEOS_BACKEND_FAMILY }, + { "HelmholtzEOSBackend", HEOS_BACKEND_FAMILY }, + { "HelmholtzEOSMixtureBackend", HEOS_BACKEND_FAMILY }, + { "REFPROP", REFPROP_BACKEND_FAMILY }, + { "REFPROPBackend", REFPROP_BACKEND_FAMILY }, + { "REFPROPMixtureBackend", REFPROP_BACKEND_FAMILY }, + { "INCOMP", INCOMP_BACKEND_FAMILY }, + { "IncompressibleBackend", INCOMP_BACKEND_FAMILY }, + { "IF97", IF97_BACKEND_FAMILY }, + { "IF97Backend", IF97_BACKEND_FAMILY }, + { "TREND", TREND_BACKEND_FAMILY }, + { "TRENDBackend", TREND_BACKEND_FAMILY }, + { "TTSE", TTSE_BACKEND_FAMILY }, + { "TTSEBackend", TTSE_BACKEND_FAMILY }, + { "BICUBIC", BICUBIC_BACKEND_FAMILY }, + { "BicubicBackend", BICUBIC_BACKEND_FAMILY }, + { "SRK", SRK_BACKEND_FAMILY }, + { "SRKBackend", SRK_BACKEND_FAMILY }, + { "PR", PR_BACKEND_FAMILY }, + { "Peng-Robinson", PR_BACKEND_FAMILY }, + { "PengRobinsonBackend", PR_BACKEND_FAMILY }, +}; +const std::map backend_mapping_reversed = { + { HEOS_BACKEND_PURE,"HelmholtzEOSBackend" }, + { HEOS_BACKEND_MIX,"HelmholtzEOSMixtureBackend" }, + { REFPROP_BACKEND_PURE,"REFPROPBackend" }, + { REFPROP_BACKEND_MIX,"REFPROPMixtureBackend" }, + { INCOMP_BACKEND,"IncompressibleBackend" }, + { IF97_BACKEND,"IF97Backend" }, + { TREND_BACKEND,"TRENDBackend" }, + { TTSE_BACKEND,"TTSEBackend" }, + { BICUBIC_BACKEND,"BicubicBackend" }, + { SRK_BACKEND,"SRKBackend" }, + { PR_BACKEND, "PengRobinsonBackend" } , +}; +const std::map backend_alias_mapping = { + { HEOS_BACKEND_FAMILY, "HEOS" }, + { REFPROP_BACKEND_FAMILY, "REFPROP" }, +}; + +/// Convert a string into the enum values +void extract_backend_enums(std::string backend_string, backend_families &f1, backend_families &f2) { + f1 = INVALID_BACKEND_FAMILY; + f2 = INVALID_BACKEND_FAMILY; + std::size_t i = backend_string.find("&"); + std::map::const_iterator it; + if (i != std::string::npos) { + it = backend_mapping.find(backend_string.substr(0, i));// Before "&" + if (it != backend_mapping.end()) f1 = it->second; + it = backend_mapping.find(backend_string.substr(i + 1)); // After "&" + if (it != backend_mapping.end()) f2 = it->second; + } else { + it = backend_mapping.find(backend_string); + if (it != backend_mapping.end()) f1 = it->second; + } +} + +void extract_backend_enums_string(std::string backend_string, backend_families &f1, std::string &f2) { + backend_families f2_enum; + extract_backend_enums(backend_string, f1, f2_enum); + std::map::const_iterator it; + it = backend_alias_mapping.find(f2_enum); + if (it != backend_alias_mapping.end()) f2 = it->second; + else f2.clear(); +} + +std::string get_backend_string(backends backend) { + std::map::const_iterator it; + it = backend_mapping_reversed.find(backend); + if (it != backend_mapping_reversed.end()) return it->second; + else return std::string(""); +} + } /* namespace CoolProp */