CoolProp  6.6.0
An open-source fluid property and humid air property database
DataStructures.h
Go to the documentation of this file.
1 /*
2  * DataStructures.h
3  *
4  * Created on: 21 Dec 2013
5  * Author: jowr
6  */
7 
8 #ifndef DATASTRUCTURES_H_
9 #define DATASTRUCTURES_H_
10 
11 #include "CPnumerics.h"
12 #include "Exceptions.h"
13 #include <map>
14 namespace CoolProp {
15 
16 struct SimpleState
17 {
18  double rhomolar, T, p, hmolar, smolar, umolar, Q;
19  SimpleState() {
20  fill(_HUGE);
21  }
22  void fill(double v) {
23  rhomolar = v;
24  T = v;
25  p = v;
26  hmolar = v;
27  smolar = v;
28  umolar = v;
29  Q = v;
30  }
31  bool is_valid() {
32  return ValidNumber(rhomolar) && ValidNumber(T) && ValidNumber(hmolar) && ValidNumber(p);
33  }
34 };
35 
36 struct CriticalState : SimpleState
37 {
38  bool stable;
39  CriticalState() : stable(false) {
40  fill(_HUGE);
41  }
42 };
43 
45 struct SsatSimpleState : public SimpleState
46 {
47  enum SsatSimpleStateEnum
48  {
49  SSAT_MAX_NOT_SET = 0,
50  SSAT_MAX_DOESNT_EXIST,
51  SSAT_MAX_DOES_EXIST
52  };
53  SsatSimpleStateEnum exists;
54  SsatSimpleState() : exists(SSAT_MAX_NOT_SET) {}
55 };
56 
62 //
63 // !! If you add a parameter, update the map in the corresponding CPP file !!
64 enum parameters
65 {
66  INVALID_PARAMETER = 0,
67 
68  // General parameters
69  igas_constant,
70  imolar_mass,
71  iacentric_factor,
72  irhomolar_reducing,
73  irhomolar_critical,
74  iT_reducing,
75  iT_critical,
76  irhomass_reducing,
77  irhomass_critical,
78  iP_critical,
79  iP_reducing,
80  iT_triple,
81  iP_triple,
82  iT_min,
83  iT_max,
84  iP_max,
85  iP_min,
86  idipole_moment,
87 
88  // Bulk properties
89  iT,
90  iP,
91  iQ,
92  iTau,
93  iDelta,
94 
95  // Molar specific thermodynamic properties
96  iDmolar,
97  iHmolar,
98  iSmolar,
99  iCpmolar,
100  iCp0molar,
101  iCvmolar,
102  iUmolar,
103  iGmolar,
104  iHelmholtzmolar,
105  iHmolar_residual,
106  iSmolar_residual,
107  iGmolar_residual,
108 
109  // Mass specific thermodynamic properties
110  iDmass,
111  iHmass,
112  iSmass,
113  iCpmass,
114  iCp0mass,
115  iCvmass,
116  iUmass,
117  iGmass,
118  iHelmholtzmass,
119 
120  // Transport properties
121  iviscosity,
122  iconductivity,
123  isurface_tension,
124  iPrandtl,
125 
126  // Derivative-based terms
127  ispeed_sound,
128  iisothermal_compressibility,
129  iisobaric_expansion_coefficient,
130  iisentropic_expansion_coefficient,
131 
132  // Fundamental derivative of gas dynamics
133  ifundamental_derivative_of_gas_dynamics,
134 
135  // Derivatives of the residual non-dimensionalized Helmholtz energy with respect to the EOS variables
136  ialphar,
137  idalphar_dtau_constdelta,
138  idalphar_ddelta_consttau,
139 
140  // Derivatives of the ideal-gas non-dimensionalized Helmholtz energy with respect to the EOS variables
141  ialpha0,
142  idalpha0_dtau_constdelta,
143  idalpha0_ddelta_consttau,
144  id2alpha0_ddelta2_consttau,
145  id3alpha0_ddelta3_consttau,
146 
147  // Other functions and derivatives
148  iBvirial,
149  iCvirial,
150  idBvirial_dT,
151  idCvirial_dT,
152  iZ,
153  iPIP,
154 
155  // Accessors for incompressibles
156  ifraction_min,
157  ifraction_max,
158  iT_freeze,
159 
160  // Environmental parameters
161  iGWP20,
162  iGWP100,
163  iGWP500,
164  iFH,
165  iHH,
166  iPH,
167  iODP,
168  iPhase,
169  iundefined_parameter
170 
171 };
172 // !! If you add a parameter, update the map in the corresponding CPP file !!
173 // !! Also update phase_lookup_string() in CoolProp.cpp !!
174 
176 enum phases
177 {
178  iphase_liquid,
179  iphase_supercritical,
180  iphase_supercritical_gas,
181  iphase_supercritical_liquid,
182  iphase_critical_point,
183  iphase_gas,
184  iphase_twophase,
185  iphase_unknown,
186  iphase_not_imposed
187 };
188 
190 enum schemes
191 {
192  i1,
193  i2a,
194  i2b,
195  i3a,
196  i3b,
197  i4a,
198  i4b,
199  i4c
200 };
201 
205 std::string get_parameter_information(int key, const std::string& info);
206 
208 parameters get_parameter_index(const std::string& param_name);
209 
213 bool is_valid_phase(const std::string& phase_name, phases& iOutput);
214 
216 phases get_phase_index(const std::string& param_name);
217 
221 bool is_valid_scheme(const std::string &scheme_name, schemes &iOutput);
222 
224 schemes get_scheme_index(const std::string &scheme_name);
225 
227 bool is_trivial_parameter(int key);
228 
230 bool is_valid_parameter(const std::string& name, parameters& iOutput);
231 
235 bool is_valid_first_derivative(const std::string& name, parameters& iOf, parameters& iWrt, parameters& iConstant);
236 
240 bool is_valid_first_saturation_derivative(const std::string& name, parameters& iOf, parameters& iWrt);
241 
245 bool is_valid_second_derivative(const std::string& name, parameters& iOf1, parameters& iWrt1, parameters& iConstant1, parameters& iWrt2,
246  parameters& iConstant2);
247 
249 std::string get_csv_parameter_list();
250 
252 enum composition_types
253 {
254  IFRAC_MASS,
255  IFRAC_MOLE,
256  IFRAC_VOLUME,
257  IFRAC_UNDEFINED,
258  IFRAC_PURE
259 };
260 
262 enum fluid_types
263 {
264  FLUID_TYPE_PURE,
265  FLUID_TYPE_PSEUDOPURE,
266  FLUID_TYPE_REFPROP,
267  FLUID_TYPE_INCOMPRESSIBLE_LIQUID,
268  FLUID_TYPE_INCOMPRESSIBLE_SOLUTION,
269  FLUID_TYPE_UNDEFINED
270 };
271 
272 // !! If you add a parameter, update the map in the corresponding CPP file !!
274 enum input_pairs
275 {
276  INPUT_PAIR_INVALID = 0, // Default (invalid) value
277  QT_INPUTS,
278  PQ_INPUTS,
279  QSmolar_INPUTS,
280  QSmass_INPUTS,
281  HmolarQ_INPUTS,
282  HmassQ_INPUTS,
283  DmolarQ_INPUTS,
284  DmassQ_INPUTS,
285 
286  PT_INPUTS,
287 
288  DmassT_INPUTS,
289  DmolarT_INPUTS,
290  HmolarT_INPUTS,
291  HmassT_INPUTS,
292  SmolarT_INPUTS,
293  SmassT_INPUTS,
294  TUmolar_INPUTS,
295  TUmass_INPUTS,
296 
297  DmassP_INPUTS,
298  DmolarP_INPUTS,
299  HmassP_INPUTS,
300  HmolarP_INPUTS,
301  PSmass_INPUTS,
302  PSmolar_INPUTS,
303  PUmass_INPUTS,
304  PUmolar_INPUTS,
305 
306  HmassSmass_INPUTS,
307  HmolarSmolar_INPUTS,
308  SmassUmass_INPUTS,
309  SmolarUmolar_INPUTS,
310 
311  DmassHmass_INPUTS,
312  DmolarHmolar_INPUTS,
313  DmassSmass_INPUTS,
314  DmolarSmolar_INPUTS,
315  DmassUmass_INPUTS,
316  DmolarUmolar_INPUTS,
317 };
318 // !! If you add or remove a parameter, update the map in the corresponding CPP file !!
319 
320 inline bool match_pair(parameters key1, parameters key2, parameters x1, parameters x2, bool& swap) {
321  swap = !(key1 == x1);
322  return ((key1 == x1 && key2 == x2) || (key2 == x1 && key1 == x2));
323 };
337 template <class T>
338 CoolProp::input_pairs generate_update_pair(parameters key1, T value1, parameters key2, T value2, T& out1, T& out2) throw() {
339  CoolProp::input_pairs pair;
340  bool swap;
341 
342  if (match_pair(key1, key2, iQ, iT, swap)) {
343  pair = QT_INPUTS;
344  } else if (match_pair(key1, key2, iP, iQ, swap)) {
345  pair = PQ_INPUTS;
346  } else if (match_pair(key1, key2, iP, iT, swap)) {
347  pair = PT_INPUTS;
348  } else if (match_pair(key1, key2, iDmolar, iT, swap)) {
349  pair = DmolarT_INPUTS; // Molar density in mol/m^3, Temperature in K
350  } else if (match_pair(key1, key2, iDmass, iT, swap)) {
351  pair = DmassT_INPUTS; // Mass density in kg/m^3, Temperature in K
352  } else if (match_pair(key1, key2, iHmolar, iT, swap)) {
353  pair = HmolarT_INPUTS; // Enthalpy in J/mol, Temperature in K
354  } else if (match_pair(key1, key2, iHmass, iT, swap)) {
355  pair = HmassT_INPUTS; // Enthalpy in J/kg, Temperature in K
356  } else if (match_pair(key1, key2, iSmolar, iT, swap)) {
357  pair = SmolarT_INPUTS; // Entropy in J/mol/K, Temperature in K
358  } else if (match_pair(key1, key2, iSmass, iT, swap)) {
359  pair = SmassT_INPUTS; // Entropy in J/kg/K, Temperature in K
360  } else if (match_pair(key1, key2, iT, iUmolar, swap)) {
361  pair = TUmolar_INPUTS; // Temperature in K, Internal energy in J/mol
362  } else if (match_pair(key1, key2, iT, iUmass, swap)) {
363  pair = TUmass_INPUTS; // Temperature in K, Internal energy in J/kg
364  } else if (match_pair(key1, key2, iDmass, iHmass, swap)) {
365  pair = DmassHmass_INPUTS; // Mass density in kg/m^3, Enthalpy in J/kg
366  } else if (match_pair(key1, key2, iDmolar, iHmolar, swap)) {
367  pair = DmolarHmolar_INPUTS; // Molar density in mol/m^3, Enthalpy in J/mol
368  } else if (match_pair(key1, key2, iDmass, iSmass, swap)) {
369  pair = DmassSmass_INPUTS; // Mass density in kg/m^3, Entropy in J/kg/K
370  } else if (match_pair(key1, key2, iDmolar, iSmolar, swap)) {
371  pair = DmolarSmolar_INPUTS; // Molar density in mol/m^3, Entropy in J/mol/K
372  } else if (match_pair(key1, key2, iDmass, iUmass, swap)) {
373  pair = DmassUmass_INPUTS; // Mass density in kg/m^3, Internal energy in J/kg
374  } else if (match_pair(key1, key2, iDmolar, iUmolar, swap)) {
375  pair = DmolarUmolar_INPUTS; // Molar density in mol/m^3, Internal energy in J/mol
376  } else if (match_pair(key1, key2, iDmass, iP, swap)) {
377  pair = DmassP_INPUTS; // Mass density in kg/m^3, Pressure in Pa
378  } else if (match_pair(key1, key2, iDmolar, iP, swap)) {
379  pair = DmolarP_INPUTS; // Molar density in mol/m^3, Pressure in Pa
380  } else if (match_pair(key1, key2, iDmass, iQ, swap)) {
381  pair = DmassQ_INPUTS; // Mass density in kg/m^3, molar vapor quality
382  } else if (match_pair(key1, key2, iDmolar, iQ, swap)) {
383  pair = DmolarQ_INPUTS; // Molar density in mol/m^3, molar vapor quality
384  } else if (match_pair(key1, key2, iHmass, iP, swap)) {
385  pair = HmassP_INPUTS; // Enthalpy in J/kg, Pressure in Pa
386  } else if (match_pair(key1, key2, iHmolar, iP, swap)) {
387  pair = HmolarP_INPUTS; // Enthalpy in J/mol, Pressure in Pa
388  } else if (match_pair(key1, key2, iP, iSmass, swap)) {
389  pair = PSmass_INPUTS; // Pressure in Pa, Entropy in J/kg/K
390  } else if (match_pair(key1, key2, iP, iSmolar, swap)) {
391  pair = PSmolar_INPUTS; // Pressure in Pa, Entropy in J/mol/K
392  } else if (match_pair(key1, key2, iP, iUmass, swap)) {
393  pair = PUmass_INPUTS; // Pressure in Pa, Internal energy in J/kg
394  } else if (match_pair(key1, key2, iP, iUmolar, swap)) {
395  pair = PUmolar_INPUTS; // Pressure in Pa, Internal energy in J/mol
396  } else if (match_pair(key1, key2, iHmass, iSmass, swap)) {
397  pair = HmassSmass_INPUTS; // Enthalpy in J/kg, Entropy in J/kg/K
398  } else if (match_pair(key1, key2, iHmolar, iSmolar, swap)) {
399  pair = HmolarSmolar_INPUTS; // Enthalpy in J/mol, Entropy in J/mol/K
400  } else if (match_pair(key1, key2, iSmass, iUmass, swap)) {
401  pair = SmassUmass_INPUTS;
402  } else if (match_pair(key1, key2, iSmolar, iUmolar, swap)) {
403  pair = SmolarUmolar_INPUTS;
404  } else {
405  pair = INPUT_PAIR_INVALID;
406  return pair;
407  }
408 
409  if (!swap) {
410  out1 = value1;
411  out2 = value2;
412  } else {
413  out1 = value2;
414  out2 = value1;
415  }
416  return pair;
417 };
418 
420 input_pairs get_input_pair_index(const std::string& input_pair_name);
421 
423 const std::string& get_input_pair_short_desc(input_pairs pair);
424 
426 const std::string& get_input_pair_long_desc(input_pairs pair);
427 
429 void split_input_pair(input_pairs pair, parameters& p1, parameters& p2);
430 
431 extern std::string get_mixture_binary_pair_data(const std::string& CAS1, const std::string& CAS2, const std::string& param);
432 extern void set_mixture_binary_pair_data(const std::string& CAS1, const std::string& CAS2, const std::string& param, const double val);
433 extern std::string get_mixture_binary_pair_pcsaft(const std::string& CAS1, const std::string& CAS2, const std::string& param);
434 extern void set_mixture_binary_pair_pcsaft(const std::string& CAS1, const std::string& CAS2, const std::string& param, const double val);
435 
437 // !! If you add a parameter, update the map in the corresponding CPP file !!
438 enum backend_families
439 {
440  INVALID_BACKEND_FAMILY = 0,
441  HEOS_BACKEND_FAMILY,
442  REFPROP_BACKEND_FAMILY,
443  INCOMP_BACKEND_FAMILY,
444  IF97_BACKEND_FAMILY,
445  TREND_BACKEND_FAMILY,
446  TTSE_BACKEND_FAMILY,
447  BICUBIC_BACKEND_FAMILY,
448  SRK_BACKEND_FAMILY,
449  PR_BACKEND_FAMILY,
450  VTPR_BACKEND_FAMILY,
451  PCSAFT_BACKEND_FAMILY
452 };
453 enum backends
454 {
455  INVALID_BACKEND = 0,
456  HEOS_BACKEND_PURE,
457  HEOS_BACKEND_MIX,
458  REFPROP_BACKEND_PURE,
459  REFPROP_BACKEND_MIX,
460  INCOMP_BACKEND,
461  IF97_BACKEND,
462  TREND_BACKEND,
463  TTSE_BACKEND,
464  BICUBIC_BACKEND,
465  SRK_BACKEND,
466  PR_BACKEND,
467  VTPR_BACKEND,
468  PCSAFT_BACKEND
469 };
470 
472 void extract_backend_families(std::string backend_string, backend_families& f1, backend_families& f2);
473 void extract_backend_families_string(std::string backend_string, backend_families& f1, std::string& f2);
474 std::string get_backend_string(backends backend);
475 
476 #if !defined(NO_FMTLIB) && FMT_VERSION >= 90000
478 inline int format_as(parameters parameter) {
479  return fmt::underlying(parameter);
480 }
481 
482 inline int format_as(phases phase) {
483  return fmt::underlying(phase);
484 }
485 
486 inline int format_as(schemes scheme) {
487  return fmt::underlying(scheme);
488 }
489 
490 inline int format_as(composition_types type) {
491  return fmt::underlying(type);
492 }
493 
494 inline int format_as(fluid_types type) {
495  return fmt::underlying(type);
496 }
497 
498 inline int format_as(input_pairs pair) {
499  return fmt::underlying(pair);
500 }
501 
502 inline int format_as(backend_families family) {
503  return fmt::underlying(family);
504 }
505 
506 inline int format_as(backends backend) {
507  return fmt::underlying(backend);
508 }
509 #endif
510 
511 } /* namespace CoolProp */
512 #endif /* DATASTRUCTURES_H_ */
Generated on Wed Nov 29 2023 14:26:23 for CoolProp by doxygen 1.9.1