CoolProp  4.2.5
An open-source fluid property and humid air property database
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
IncompLiquid.h
Go to the documentation of this file.
1 
2 #ifndef INCOMPRESSIBLE_LIQUID_H
3 #define INCOMPRESSIBLE_LIQUID_H
4 
5 #include <string>
6 #include <vector>
7 #include <math.h>
8 #include "CPExceptions.h"
9 #include "CoolPropTools.h"
10 #include "IncompBase.h"
11 #include <stdio.h>
12 
21 
25 class IncompressibleLiquid : public IncompressibleClass{
26 
27 public:
28  /* All functions need T and p as input. Might not be necessary,
29  * but gives a clearer structure.
30  */
32  virtual double rho (double T_K, double p){return -_HUGE;};
34  virtual double c (double T_K, double p){return -_HUGE;};
35  virtual double cp (double T_K, double p){return c(T_K,p);};
36  virtual double cv (double T_K, double p){return c(T_K,p);};
38  virtual double s (double T_K, double p){return -_HUGE;};
40  virtual double u (double T_K, double p){return -_HUGE;};
42  virtual double h (double T_K, double p){return -_HUGE;};
44  virtual double visc(double T_K, double p){return -_HUGE;};
46  virtual double cond(double T_K, double p){return -_HUGE;};
48  virtual double psat(double T_K){return -_HUGE;};
49 
50  void testInputs(double T_K, double p);
51 
52 protected:
53  /* Define internal energy and enthalpy as functions of the
54  * other properties to provide data in case there are no
55  * coefficients.
56  */
57 
59 
62  double h_u(double T_K, double p) {
63  return u(T_K,p)+p/rho(T_K,p);
64  };
65 
67 
70  double u_h(double T_K, double p) {
71  return h(T_K,p)-p/rho(T_K,p);
72  };
73 
74 
75  /*
76  * Some more functions to provide a single implementation
77  * of important routines.
78  * We start with the check functions that can validate input
79  * in terms of pressure p and temperature T.
80  */
81 
83 
86  bool checkT(double T_K);
87 
89 
95  bool checkP(double T_K, double p);
96 
98  bool checkTP(double T, double p);
99 };
100 
101 
106 bool IsIncompressibleLiquid(std::string name);
107 double IncompLiquidSI(long iOutput, double T, double p, long iFluid);
108 double IncompLiquidSI(long iOutput, double T, double p, std::string name);
109 // only two functions needed
110 // no name processing
111 // no concentration issues
112 
113 
116 class LiquidsContainer {
117 private:
118  std::vector<IncompressibleLiquid*> liquid_list;
119  std::map<std::string,IncompressibleLiquid*> liquid_map;
120 
121 public:
122  IncompressibleLiquid * get_liquid(long index);
123  IncompressibleLiquid * get_liquid(std::string name);
124  void set_liquids(std::vector<IncompressibleLiquid*> list);
125 
126  LiquidsContainer();
127  ~LiquidsContainer();
128 };
129 
130 
132 
137 class SimpleIncompressible : public IncompressibleLiquid{
138 protected:
139  std::vector<double> cRho;
140  std::vector<double> cHeat;
141  std::vector<double> cVisc;
142  std::vector<double> cCond;
143  std::vector<double> cPsat;
144 
145 public:
146  double rho(double T_K, double p){
147  checkTP(T_K, p);
148  return polyval(cRho, T_K);
149  }
150  double c(double T_K, double p){
151  checkTP(T_K, p);
152  return polyval(cHeat, T_K);
153  }
154  double h(double T_K, double p){
155  checkTP(T_K, p);
156  return h_u(T_K,p);
157  }
158  double s(double T_K, double p){
159  checkTP(T_K, p);
160  return polyfracint(cHeat, T_K, Tref);
161  }
162  double visc(double T_K, double p){
163  checkTP(T_K, p);
164  return expval(cVisc, T_K, 1);
165  }
166  double cond(double T_K, double p){
167  checkTP(T_K, p);
168  return polyval(cCond, T_K);
169  }
170  double u(double T_K, double p){
171  return polyint(cHeat, T_K, Tref);
172  }
173  double psat(double T_K){
174  checkT(T_K);
175  if (T_K<TminPsat || TminPsat<0){
176  return -1.;
177  } else {
178  return expval(cPsat, T_K, 1);
179  }
180  };
181 };
182 
183 /*
184  * The next classes follow the structure initially developed by Ian
185  * to fit the data from Melinder-BOOK-2010.
186  */
187 class DEBLiquidClass : public SimpleIncompressible{
188 public:
189  DEBLiquidClass(){
190  name = std::string("DEB");
191  description = std::string("Diethylbenzene mixture - Dowtherm J Dow Chemical Co.");
192  reference = std::string("Melinder-BOOK-2010");
193 
194  Tmin = -80.0 + 273.15;
195  Tmax = 100.0 + 273.15;
196 
197  cRho.clear();
198  cRho.push_back(1076.5);
199  cRho.push_back(-0.731182);
200 
201  cHeat.clear();
202  cHeat.push_back(999.729);
203  cHeat.push_back(2.87576);
204 
205  cVisc.clear();
206  cVisc.push_back(3.5503);
207  cVisc.push_back(-0.0566396);
208  cVisc.push_back(7.03331e-05);
209 
210  cCond.clear();
211  cCond.push_back(0.000189132);
212  cCond.push_back(-2.06364e-07);
213  };
214  double visc(double T_K, double p){
215  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
216  return expval(cVisc, T_K, 2);
217  }
218 };
219 
220 class HCMLiquidClass : public SimpleIncompressible{
221 public:
222  HCMLiquidClass(){
223  name = std::string("HCM");
224  description = std::string("Hydrocarbon mixture (synthetic) - Therminol D12 (Gilotherm D12) Solutia");
225  reference = std::string("Melinder-BOOK-2010");
226 
227  Tmin = -80.0 + 273.15;
228  Tmax = 100.0 + 273.15;
229 
230  cRho.clear();
231  cRho.push_back(971.725);
232  cRho.push_back(-0.718788);
233 
234  cHeat.clear();
235  cHeat.push_back(844.023);
236  cHeat.push_back(4.31212);
237 
238  cVisc.clear();
239  cVisc.push_back(18.3237);
240  cVisc.push_back(-0.14706);
241  cVisc.push_back(0.000209096);
242 
243  cCond.clear();
244  cCond.push_back(0.000153716);
245  cCond.push_back(-1.51212e-07);
246  };
247  double visc(double T_K, double p){
248  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
249  return expval(cVisc, T_K, 2);
250  }
251 };
252 
253 class HFELiquidClass : public SimpleIncompressible{
254 public:
255  HFELiquidClass(){
256  name = std::string("HFE");
257  description = std::string("Hydrofluoroether - HFE-7100 3M Novec");
258  reference = std::string("Melinder-BOOK-2010");
259 
260  Tmin = -80.0 + 273.15;
261  Tmax = 100.0 + 273.15;
262 
263  cRho.clear();
264  cRho.push_back(1822.37);
265  cRho.push_back(-0.918485);
266 
267  cHeat.clear();
268  cHeat.push_back(871.834);
269  cHeat.push_back(858788);
270 
271  cVisc.clear();
272  cVisc.push_back(-4.22878);
273  cVisc.push_back(-0.0114765);
274  cVisc.push_back(7.39823e-06);
275 
276  cCond.clear();
277  cCond.push_back(9.92958e-05);
278  cCond.push_back(-8.33333e-08);
279  };
280  double visc(double T_K, double p){
281  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
282  return expval(cVisc, T_K, 2);
283  }
284 };
285 
286 class PMS1LiquidClass : public SimpleIncompressible{
287 public:
288  PMS1LiquidClass(){
289  name = std::string("PMS1");
290  description = std::string("Polydimethylsiloxan 1. - Baysilone KT3");
291  reference = std::string("Melinder-BOOK-2010");
292 
293  Tmin = -80.0 + 273.15;
294  Tmax = 100.0 + 273.15;
295 
296  cRho.clear();
297  cRho.push_back(1172.35);
298  cRho.push_back(-0.9025);
299 
300  cHeat.clear();
301  cHeat.push_back(1223.69);
302  cHeat.push_back(1.48417);
303 
304  cVisc.clear();
305  cVisc.push_back(6.36183);
306  cVisc.push_back(-0.0636352);
307  cVisc.push_back(7.51428e-05);
308 
309  cCond.clear();
310  cCond.push_back(0.000207526);
311  cCond.push_back(-2.84167e-07);
312  };
313  double visc(double T_K, double p){
314  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
315  return expval(cVisc, T_K, 2);
316  }
317 };
318 
319 class PMS2LiquidClass : public SimpleIncompressible{
320 public:
321  PMS2LiquidClass(){
322  name = std::string("PMS2");
323  description = std::string("Polydimethylsiloxan 2. - Syltherm XLT Dow Corning Co.");
324  reference = std::string("Melinder-BOOK-2010");
325 
326  Tmin = -80.0 + 273.15;
327  Tmax = 100.0 + 273.15;
328 
329  cRho.clear();
330  cRho.push_back(1155.94);
331  cRho.push_back(-1.02576);
332 
333  cHeat.clear();
334  cHeat.push_back(1153.55);
335  cHeat.push_back(2.10788);
336 
337  cVisc.clear();
338  cVisc.push_back(5.66926);
339  cVisc.push_back(-0.065582);
340  cVisc.push_back(8.09988e-05);
341 
342  cCond.clear();
343  cCond.push_back(0.000172305);
344  cCond.push_back(-2.11212e-07);
345  };
346  double visc(double T_K, double p){
347  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
348  return expval(cVisc, T_K, 2);
349  }
350 };
351 
352 class SABLiquidClass : public SimpleIncompressible{
353 public:
354  SABLiquidClass(){
355  name = std::string("SAB");
356  description = std::string("Synthetic alkyl benzene - Marlotherm X");
357  reference = std::string("Melinder-BOOK-2010");
358 
359  Tmin = -80.0 + 273.15;
360  Tmax = 100.0 + 273.15;
361 
362  cRho.clear();
363  cRho.push_back(1102.34);
364  cRho.push_back(-0.801667);
365 
366  cHeat.clear();
367  cHeat.push_back(1360.94);
368  cHeat.push_back(1.51667);
369 
370  cVisc.clear();
371  cVisc.push_back(5.21288);
372  cVisc.push_back(-0.0665792);
373  cVisc.push_back(8.5066e-05);
374 
375  cCond.clear();
376  cCond.push_back(0.000208374);
377  cCond.push_back(-2.61667e-07);
378  };
379  double visc(double T_K, double p){
380  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
381  return expval(cVisc, T_K, 2);
382  }
383 };
384 
385 class HCBLiquidClass : public SimpleIncompressible{
386 public:
387  HCBLiquidClass(){
388  name = std::string("HCB");
389  description = std::string("Hydrocarbon blend - Dynalene MV");
390  reference = std::string("Melinder-BOOK-2010");
391 
392  Tmin = -80.0 + 273.15;
393  Tmax = 100.0 + 273.15;
394 
395  cRho.clear();
396  cRho.push_back(1071.78);
397  cRho.push_back(-0.772024);
398 
399  cHeat.clear();
400  cHeat.push_back(761.393);
401  cHeat.push_back(3.52976);
402 
403  cVisc.clear();
404  cVisc.push_back(7.16819);
405  cVisc.push_back(-0.0863212);
406  cVisc.push_back(0.000130604);
407 
408  cCond.clear();
409  cCond.push_back(0.000203186);
410  cCond.push_back(-2.3869e-07);
411  };
412  double visc(double T_K, double p){
413  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
414  return expval(cVisc, T_K, 2);
415  }
416 };
417 
418 class TCOLiquidClass : public SimpleIncompressible{
419 public:
420  TCOLiquidClass(){
421  name = std::string("TCO");
422  description = std::string("Terpene from citrus oils - d-Limonene");
423  reference = std::string("Melinder-BOOK-2010");
424 
425  Tmin = -80.0 + 273.15;
426  Tmax = 100.0 + 273.15;
427 
428  cRho.clear();
429  cRho.push_back(1071.02);
430  cRho.push_back(-0.778166);
431 
432  cHeat.clear();
433  cHeat.push_back(223.775);
434  cHeat.push_back(5.2159);
435 
436  cVisc.clear();
437  cVisc.push_back(-3.47971);
438  cVisc.push_back(-0.0107031);
439  cVisc.push_back(1.14086e-06);
440 
441  cCond.clear();
442  cCond.push_back(0.000174156);
443  cCond.push_back(-1.85052e-07);
444  };
445  double visc(double T_K, double p){
446  if (!checkTP(T_K, p)) throw ValueError(format("T=%f or p=%f is out of range.",T_K,p));
447  return expval(cVisc, T_K, 2);
448  }
449 };
450 
451 
453 
464 
469 class TherminolD12Class : public SimpleIncompressible{
470 public:
471  TherminolD12Class(){
472  name = std::string("TD12");
473  description = std::string("Therminol D12");
474  reference = std::string("Therminol2007");
475 
476  Tmin = 188.15;
477  Tmax = 503.15;
478  TminPsat = 188.15;
479 
480  cRho.clear();
481  cRho.push_back(+9.8351112723E+02);
482  cRho.push_back(-9.2980873989E-01);
483  cRho.push_back(+1.0537525196E-03);
484  cRho.push_back(-1.5498113539E-06);
485 
486  cHeat.clear();
487  cHeat.push_back(+9.8364476562E+02);
488  cHeat.push_back(+3.8726050231E+00);
489  cHeat.push_back(-9.8766309005E-04);
490  cHeat.push_back(+2.3435575994E-06);
491 
492  cCond.clear();
493  cCond.push_back(+1.4137409273E-01);
494  cCond.push_back(-5.9980348818E-05);
495  cCond.push_back(-1.6084318907E-07);
496 
497  cVisc.clear();
498  cVisc.push_back(+5.6521089774E+02);
499  cVisc.push_back(-1.2468427934E+02);
500  cVisc.push_back(+1.0064677576E+01);
501 
502  cPsat.clear();
503  cPsat.push_back(-3.4575358232E+03);
504  cPsat.push_back(-8.2860659877E+01);
505  cPsat.push_back(-2.0569899350E+01);
506  };
507 };
508 
509 class TherminolVP1Class : public SimpleIncompressible{
510 public:
511  TherminolVP1Class(){
512  name = std::string("TVP1");
513  description = std::string("Therminol VP-1");
514  reference = std::string("Therminol2007");
515 
516  Tmin = 285.15;
517  Tmax = 670.15;
518  TminPsat = 285.15;
519 
520  cRho.clear();
521  cRho.push_back(+1.4027134791E+03);
522  cRho.push_back(-1.6132556454E+00);
523  cRho.push_back(+2.1378385004E-03);
524  cRho.push_back(-1.9310694268E-06);
525 
526  cHeat.clear();
527  cHeat.push_back(+2.8811134920E+02);
528  cHeat.push_back(+5.8749383495E+00);
529  cHeat.push_back(-6.8565802314E-03);
530  cHeat.push_back(+4.8441771885E-06);
531 
532  cCond.clear();
533  cCond.push_back(+1.4898820987E-01);
534  cCond.push_back(+7.4237598012E-06);
535  cCond.push_back(-1.7298441066E-07);
536 
537  cVisc.clear();
538  cVisc.push_back(+1.0739262698E+03);
539  cVisc.push_back(-8.3841432169E+01);
540  cVisc.push_back(+1.0616847324E+01);
541 
542  cPsat.clear();
543  cPsat.push_back(-4.3138714911E+03);
544  cPsat.push_back(-8.7431401731E+01);
545  cPsat.push_back(-2.1266245816E+01);
546  };
547 };
548 
549 class Therminol66Class : public SimpleIncompressible{
550 public:
551  Therminol66Class(){
552  name = std::string("T66");
553  description = std::string("Therminol 66");
554  reference = std::string("Therminol2007");
555 
556  Tmin = 273.15;
557  Tmax = 653.15;
558  TminPsat = 343.15;
559 
560  cRho.clear();
561  cRho.push_back(+1.1644533740E+03);
562  cRho.push_back(-4.3889170000E-01);
563  cRho.push_back(-3.2100000000E-04);
564  cRho.push_back(+3.7806951741E-20);
565 
566  cHeat.clear();
567  cHeat.push_back(+6.5799090444E+02);
568  cHeat.push_back(+2.8229260154E+00);
569  cHeat.push_back(+8.9707850000E-04);
570  cHeat.push_back(-6.3169106168E-20);
571 
572  cCond.clear();
573  cCond.push_back(+1.1611631163E-01);
574  cCond.push_back(+4.8945000000E-05);
575  cCond.push_back(-1.5000000000E-07);
576 
577  cVisc.clear();
578  cVisc.push_back(+6.6720362621E+02);
579  cVisc.push_back(-2.0480017928E+02);
580  cVisc.push_back(+9.5933675483E+00);
581 
582  cPsat.clear();
583  cPsat.push_back(-9.0945100000E+03);
584  cPsat.push_back(+6.6850000000E+01);
585  cPsat.push_back(-2.4544855279E+01);
586  };
587 };
588 
589 class Therminol72Class : public SimpleIncompressible{
590 public:
591  Therminol72Class(){
592  name = std::string("T72");
593  description = std::string("Therminol 72");
594  reference = std::string("Therminol2007");
595 
596  Tmin = 263.15;
597  Tmax = 653.15;
598  TminPsat = 263.15;
599 
600  cRho.clear();
601  cRho.push_back(+1.3571809600E+03);
602  cRho.push_back(-9.8961574320E-01);
603  cRho.push_back(+1.7605076030E-04);
604  cRho.push_back(-1.1893027931E-07);
605 
606  cHeat.clear();
607  cHeat.push_back(+7.5732470240E+02);
608  cHeat.push_back(+2.7131176015E+00);
609  cHeat.push_back(-6.5480236953E-06);
610  cHeat.push_back(+4.2717093140E-09);
611 
612  cCond.clear();
613  cCond.push_back(+1.7514206624E-01);
614  cCond.push_back(-1.2131347146E-04);
615  cCond.push_back(-4.0981053641E-11);
616 
617  cVisc.clear();
618  cVisc.push_back(+6.8390591135E+02);
619  cVisc.push_back(-1.8024924396E+02);
620  cVisc.push_back(+1.0066296341E+01);
621 
622  cPsat.clear();
623  cPsat.push_back(-2.9571373614E+05);
624  cPsat.push_back(+3.7936374754E+03);
625  cPsat.push_back(-7.9704232489E+01);
626  };
627 };
628 
629 
630 class DowthermJClass : public SimpleIncompressible{
631 public:
632  DowthermJClass(){
633  name = std::string("DowJ");
634  description = std::string("Dowtherm J");
635  reference = std::string("Dow Chemicals data sheet");
636 
637  Tmin = 193.15;
638  Tmax = 618.15;
639  TminPsat = 323.15;
640 
641  cRho.clear();
642  cRho.push_back(+1.1413344369E+03);
643  cRho.push_back(-1.4313342989E+00);
644  cRho.push_back(+2.4904469643E-03);
645  cRho.push_back(-2.9222651755E-06);
646 
647  cHeat.clear();
648  cHeat.push_back(+9.6069502370E+02);
649  cHeat.push_back(+3.6462333255E+00);
650  cHeat.push_back(-4.2068387567E-03);
651  cHeat.push_back(+6.7827145865E-06);
652 
653  cCond.clear();
654  cCond.push_back(+1.8990894140E-01);
655  cCond.push_back(-2.0921054918E-04);
656  cCond.push_back(-3.2093847177E-09);
657 
658  cVisc.clear();
659  cVisc.push_back(+7.0729353166E+02);
660  cVisc.push_back(-6.3966539111E+01);
661  cVisc.push_back(+1.0085461875E+01);
662 
663  cPsat.clear();
664  cPsat.push_back(-3.1876142878E+03);
665  cPsat.push_back(-9.7928074744E+01);
666  cPsat.push_back(-2.0484211718E+01);
667  };
668 };
669 
670 class DowthermQClass : public SimpleIncompressible{
671 public:
672  DowthermQClass(){
673  name = std::string("DowQ");
674  description = std::string("Dowtherm Q");
675  reference = std::string("Dow Chemicals data sheet");
676 
677  Tmin = 238.15;
678  Tmax = 633.15;
679  TminPsat = 393.15;
680 
681  cRho.clear();
682  cRho.push_back(+1.2033275827E+03);
683  cRho.push_back(-8.6829833766E-01);
684  cRho.push_back(+2.4832881863E-04);
685  cRho.push_back(-1.7756119683E-07);
686 
687  cHeat.clear();
688  cHeat.push_back(+6.8024152924E+02);
689  cHeat.push_back(+3.4510813383E+00);
690  cHeat.push_back(-4.2748801499E-04);
691  cHeat.push_back(-8.5970499813E-08);
692 
693  cCond.clear();
694  cCond.push_back(+1.5381076524E-01);
695  cCond.push_back(-9.0635332892E-05);
696  cCond.push_back(-6.2655520296E-08);
697 
698  cVisc.clear();
699  cVisc.push_back(+8.2860901780E+02);
700  cVisc.push_back(-1.2328762540E+02);
701  cVisc.push_back(+1.0441389885E+01);
702 
703  cPsat.clear();
704  cPsat.push_back(-2.8419559652E+03);
705  cPsat.push_back(-1.7104073646E+02);
706  cPsat.push_back(-1.9195781229E+01);
707  };
708 };
709 
710 
711 class Texatherm22Class : public SimpleIncompressible{
712 public:
713  Texatherm22Class(){
714  name = std::string("TX22");
715  description = std::string("Texatherm22");
716  reference = std::string("Texaco data sheet");
717 
718  Tmin = 273.15;
719  Tmax = 623.15;
720  TminPsat = 313.15;
721 
722  cRho.clear();
723  cRho.push_back(+1.0828544667E+03);
724  cRho.push_back(-9.4455186919E-01);
725  cRho.push_back(+9.2414399492E-04);
726  cRho.push_back(-9.5365423381E-07);
727 
728  cHeat.clear();
729  cHeat.push_back(+7.7399470257E+02);
730  cHeat.push_back(+3.8528705501E+00);
731  cHeat.push_back(-2.7313597680E-04);
732  cHeat.push_back(+4.3191182489E-08);
733 
734  cCond.clear();
735  cCond.push_back(+1.5246860010E-01);
736  cCond.push_back(-5.9875211524E-05);
737  cCond.push_back(-1.4202283025E-08);
738 
739  cVisc.clear();
740  cVisc.push_back(+8.8295948920E+02);
741  cVisc.push_back(-1.7261015666E+02);
742  cVisc.push_back(+9.6466062231E+00);
743 
744  cPsat.clear();
745  cPsat.push_back(-8.8969171641E+03);
746  cPsat.push_back(-4.3461866340E+01);
747  cPsat.push_back(-2.4380261252E+01);
748  };
749 };
750 
751 
752 class NitrateSaltClass : public SimpleIncompressible{
753 public:
754  NitrateSaltClass(){
755  name = std::string("NaK");
756  description = std::string("Salt mixture with 60% NaNO3 and 40% KNO3");
757  reference = std::string("Zavoico2001");
758 
759  Tmin = 573.15;
760  Tmax = 873.15;
761  TminPsat = 873.15;
762 
763  cRho.clear();
764  cRho.push_back(+2.2637234000E+03);
765  cRho.push_back(-6.3600000000E-01);
766  cRho.push_back(-4.4160301079E-16);
767  cRho.push_back(+2.0083875178E-19);
768 
769  cHeat.clear();
770  cHeat.push_back(+1.3960182000E+03);
771  cHeat.push_back(+1.7200000000E-01);
772  cHeat.push_back(-3.4511849814E-17);
773  cHeat.push_back(+1.7449850640E-20);
774 
775  cCond.clear();
776  cCond.push_back(+3.9110150000E-01);
777  cCond.push_back(+1.9000000000E-04);
778  cCond.push_back(+6.2250839227E-21);
779 
780  cVisc.clear();
781  cVisc.push_back(+4.7467256848E+02);
782  cVisc.push_back(-3.3943569983E+02);
783  cVisc.push_back(+7.7431109204E+00);
784 
785  cPsat.clear();
786  };
787 };
788 
789 
790 class SylthermXLTClass : public SimpleIncompressible{
791 public:
792  SylthermXLTClass(){
793 
794  name = std::string("XLT");
795  description = std::string("SylthermXLT");
796  reference = std::string("Dow Chemicals data sheet");
797 
798  Tmin = 173.15;
799  Tmax = 533.15;
800  TminPsat = 533.15;
801 
802  cRho.clear();
803  cRho.push_back(+1.1563685145E+03);
804  cRho.push_back(-1.0269048032E+00);
805  cRho.push_back(-9.3506079577E-07);
806  cRho.push_back(+1.0368116627E-09);
807 
808  cHeat.clear();
809  cHeat.push_back(+1.1562261074E+03);
810  cHeat.push_back(+2.0994549103E+00);
811  cHeat.push_back(+7.7175381057E-07);
812  cHeat.push_back(-3.7008444051E-20);
813 
814  cCond.clear();
815  cCond.push_back(+1.6121957379E-01);
816  cCond.push_back(-1.3023781944E-04);
817  cCond.push_back(-1.4395238766E-07);
818 
819  cVisc.clear();
820  cVisc.push_back(+1.0337654989E+03);
821  cVisc.push_back(-4.3322764383E+01);
822  cVisc.push_back(+1.0715062356E+01);
823 
824  cPsat.clear();
825  };
826 };
827 
828 class HC50Class : public SimpleIncompressible{
829 public:
830  HC50Class(){
831 
832  description = std::string("Dynalene HC-50");
833  name = std::string("HC50");
834  reference = std::string("Dynalene data sheet");
835 
836  Tmin = 223.15;
837  Tmax = 483.15;
838  TminPsat = 293.15;
839 
840  cRho.clear();
841  cRho.push_back(+1.4989450835E+03);
842  cRho.push_back(-5.2796479536E-01);
843  cRho.push_back(-7.1686735997E-05);
844  cRho.push_back(+6.2219602450E-08);
845 
846  cHeat.clear();
847  cHeat.push_back(+2.1287827711E+03);
848  cHeat.push_back(+1.9224638196E+00);
849  cHeat.push_back(+1.3287279132E-04);
850  cHeat.push_back(-1.2116448898E-07);
851 
852  cCond.clear();
853  cCond.push_back(+2.1115985069E-01);
854  cCond.push_back(+1.0044355501E-03);
855  cCond.push_back(-6.8418171866E-09);
856 
857  cVisc.clear();
858  cVisc.push_back(+5.1474948873E+02);
859  cVisc.push_back(-1.2991405965E+02);
860  cVisc.push_back(+8.8804895031E+00);
861 
862  cPsat.clear();
863  cPsat.push_back(-4.1833595311E+03);
864  cPsat.push_back(-3.3779925774E+01);
865  cPsat.push_back(-2.3219027215E+01);
866  };
867 };
868 
869 class HC40Class : public SimpleIncompressible{
870 public:
871  HC40Class(){
872 
873  description = std::string("Dynalene HC-40");
874  name = std::string("HC40");
875  reference = std::string("Dynalene data sheet");
876 
877  Tmin = 233.15;
878  Tmax = 473.15;
879  TminPsat = 293.15;
880 
881  cRho.clear();
882  cRho.push_back(+1.4720776473E+03);
883  cRho.push_back(-5.0388465311E-01);
884  cRho.push_back(-1.4487525769E-04);
885  cRho.push_back(+1.2228923117E-07);
886 
887  cHeat.clear();
888  cHeat.push_back(+2.2849444547E+03);
889  cHeat.push_back(+2.1363723550E+00);
890  cHeat.push_back(+3.3322790115E-04);
891  cHeat.push_back(-2.2099478511E-07);
892 
893  cCond.clear();
894  cCond.push_back(+2.1585000000E-01);
895  cCond.push_back(+1.0000000000E-03);
896  cCond.push_back(-1.0218829918E-20);
897 
898  cVisc.clear();
899  cVisc.push_back(+6.7794306641E+02);
900  cVisc.push_back(-1.0098293303E+02);
901  cVisc.push_back(+9.4355407493E+00);
902 
903  cPsat.clear();
904  cPsat.push_back(-5.5466979146E+03);
905  cPsat.push_back(+1.0982652329E+01);
906  cPsat.push_back(-2.5451884216E+01);
907  };
908 };
909 
910 class HC30Class : public SimpleIncompressible{
911 public:
912  HC30Class(){
913 
914  description = std::string("Dynalene HC-30");
915  name = std::string("HC30");
916  reference = std::string("Dynalene data sheet");
917 
918  Tmin = 243.15;
919  Tmax = 483.15;
920  TminPsat = 293.15;
921 
922  cRho.clear();
923  cRho.push_back(+1.4153034908E+03);
924  cRho.push_back(-4.4327434107E-01);
925  cRho.push_back(-1.5443642107E-04);
926  cRho.push_back(+1.1429794039E-07);
927 
928  cHeat.clear();
929  cHeat.push_back(+2.3846023310E+03);
930  cHeat.push_back(+2.4376868197E+00);
931  cHeat.push_back(-3.5495726496E-04);
932  cHeat.push_back(+3.2206119163E-07);
933 
934  cCond.clear();
935  cCond.push_back(+2.2585000000E-01);
936  cCond.push_back(+1.0000000000E-03);
937  cCond.push_back(-7.8145179951E-21);
938 
939  cVisc.clear();
940  cVisc.push_back(+1.4791319182E+03);
941  cVisc.push_back(+4.3364527896E+00);
942  cVisc.push_back(+1.0940969046E+01);
943 
944  cPsat.clear();
945  cPsat.push_back(-3.9183978747E+03);
946  cPsat.push_back(-4.4556553119E+01);
947  cPsat.push_back(-2.3041842217E+01);
948  };
949 };
950 
951 class HC20Class : public SimpleIncompressible{
952 public:
953  HC20Class(){
954 
955  description = std::string("DynaleneHC-20");
956  name = std::string("HC20");
957  reference = std::string("Dynalene data sheet");
958 
959  Tmin = 253.15;
960  Tmax = 483.15;
961  TminPsat = 293.15;
962 
963  cRho.clear();
964  cRho.push_back(+1.3918918541E+03);
965  cRho.push_back(-5.3737521962E-01);
966  cRho.push_back(+4.1692735606E-05);
967  cRho.push_back(-2.8527564759E-08);
968 
969  cHeat.clear();
970  cHeat.push_back(+2.5186678435E+03);
971  cHeat.push_back(+2.3663436544E+00);
972  cHeat.push_back(-9.6739411954E-06);
973  cHeat.push_back(+1.8768134708E-09);
974 
975  cCond.clear();
976  cCond.push_back(+2.2985000000E-01);
977  cCond.push_back(+1.0000000000E-03);
978  cCond.push_back(+4.2380113949E-21);
979 
980  cVisc.clear();
981  cVisc.push_back(+1.4573630736E+03);
982  cVisc.push_back(+8.3287350365E+00);
983  cVisc.push_back(+1.0986724162E+01);
984 
985  cPsat.clear();
986  cPsat.push_back(-4.2012148268E+03);
987  cPsat.push_back(-3.2285491186E+01);
988  cPsat.push_back(-2.3529315156E+01);
989  };
990 };
991 
992 class HC10Class : public SimpleIncompressible{
993 public:
994  HC10Class(){
995 
996  description = std::string("Dynalene HC-10");
997  name = std::string("HC10");
998  reference = std::string("Dynalene data sheet");
999 
1000  Tmin = 263.15;
1001  Tmax = 491.15;
1002  TminPsat = 293.15;
1003 
1004  cRho.clear();
1005  cRho.push_back(+1.3210573130E+03);
1006  cRho.push_back(-4.2690361588E-01);
1007  cRho.push_back(-9.9246921529E-05);
1008  cRho.push_back(+1.1284336656E-07);
1009 
1010  cHeat.clear();
1011  cHeat.push_back(+2.5991164581E+03);
1012  cHeat.push_back(+2.4340563753E+00);
1013  cHeat.push_back(+1.2102227066E-04);
1014  cHeat.push_back(-1.0475863139E-07);
1015 
1016  cCond.clear();
1017  cCond.push_back(+2.3085000000E-01);
1018  cCond.push_back(+1.0000000000E-03);
1019  cCond.push_back(+4.8188007943E-22);
1020 
1021  cVisc.clear();
1022  cVisc.push_back(+1.3099267208E+03);
1023  cVisc.push_back(-5.1123036317E+00);
1024  cVisc.push_back(+1.0880904782E+01);
1025 
1026  cPsat.clear();
1027  cPsat.push_back(-4.0554351446E+03);
1028  cPsat.push_back(-3.8590604800E+01);
1029  cPsat.push_back(-2.3416001339E+01);
1030  };
1031 };
1032 
1033 class AS10Class : public SimpleIncompressible{
1034 public:
1035  AS10Class(){
1036 
1037  name = std::string("AS10");
1038  description = std::string("Aspen Temper -10");
1039  reference = std::string("SecCool Software");
1040 
1041  Tmin = 265.0;
1042  Tmax = 300.0;
1043  TminPsat = 300.0;
1044 
1045  cRho.clear();
1046  cRho.push_back(+1.1446000000E+03);
1047  cRho.push_back(-2.0000000000E-01);
1048  cRho.push_back(+1.0520504534E-16);
1049  cRho.push_back(-7.3416990543E-20);
1050 
1051  cHeat.clear();
1052  cHeat.push_back(+2.0019857143E+03);
1053  cHeat.push_back(+9.2664285714E+00);
1054  cHeat.push_back(-1.3285714286E-02);
1055  cHeat.push_back(-1.3575719937E-16);
1056 
1057  cCond.clear();
1058  cCond.push_back(+1.2439404762E-01);
1059  cCond.push_back(+1.3752380952E-03);
1060  cCond.push_back(+1.9047619048E-07);
1061 
1062  cVisc.clear();
1063  cVisc.push_back(+4.7558729987E+02);
1064  cVisc.push_back(-1.6103694674E+02);
1065  cVisc.push_back(+1.0129670635E+01);
1066 
1067  cPsat.clear();
1068  };
1069 };
1070 
1071 class AS20Class : public SimpleIncompressible{
1072 public:
1073  AS20Class(){
1074 
1075  name = std::string("AS20");
1076  description = std::string("Aspen Temper -20");
1077  reference = std::string("SecCool Software");
1078 
1079  Tmin = 255.0;
1080  Tmax = 300.0;
1081  TminPsat = 300.0;
1082 
1083  cRho.clear();
1084  cRho.push_back(+1.1052186014E+03);
1085  cRho.push_back(+4.9151515152E-01);
1086  cRho.push_back(-1.1118881119E-03);
1087  cRho.push_back(-4.6620046617E-07);
1088 
1089  cHeat.clear();
1090  cHeat.push_back(+1.5218579021E+03);
1091  cHeat.push_back(+1.0060303030E+01);
1092  cHeat.push_back(-1.4137529138E-02);
1093  cHeat.push_back(+2.3310023312E-06);
1094 
1095  cCond.clear();
1096  cCond.push_back(+1.1390909091E-01);
1097  cCond.push_back(+1.3430303030E-03);
1098  cCond.push_back(-6.7271158343E-20);
1099 
1100  cVisc.clear();
1101  cVisc.push_back(+4.8319746232E+02);
1102  cVisc.push_back(-1.5863708418E+02);
1103  cVisc.push_back(+9.9041817702E+00);
1104 
1105  cPsat.clear();
1106 
1107  };
1108 };
1109 
1110 class AS30Class : public SimpleIncompressible{
1111 public:
1112  AS30Class(){
1113 
1114  name = std::string("AS30");
1115  description = std::string("Aspen Temper -30");
1116  reference = std::string("SecCool Software");
1117 
1118  Tmin = 245.0;
1119  Tmax = 300.0;
1120  TminPsat = 300.0;
1121 
1122  cRho.clear();
1123  cRho.push_back(+8.7111547342E+02);
1124  cRho.push_back(+3.7745669146E+00);
1125  cRho.push_back(-1.3928293928E-02);
1126  cRho.push_back(+1.5747215747E-05);
1127 
1128  cHeat.clear();
1129  cHeat.push_back(+3.0785717616E+02);
1130  cHeat.push_back(+1.7014884005E+01);
1131  cHeat.push_back(-2.4269064269E-02);
1132  cHeat.push_back(-3.4188034188E-06);
1133 
1134  cCond.clear();
1135  cCond.push_back(+1.1394827672E-01);
1136  cCond.push_back(+1.2806543457E-03);
1137  cCond.push_back(-4.4955044955E-08);
1138 
1139  cVisc.clear();
1140  cVisc.push_back(+5.1209144775E+02);
1141  cVisc.push_back(-1.5626579962E+02);
1142  cVisc.push_back(+9.9016607949E+00);
1143 
1144  cPsat.clear();
1145 
1146  };
1147 };
1148 
1149 class AS40Class : public SimpleIncompressible{
1150 public:
1151  AS40Class(){
1152 
1153  name = std::string("AS40");
1154  description = std::string("Aspen Temper -40");
1155  reference = std::string("SecCool Software");
1156 
1157  Tmin = 235.0;
1158  Tmax = 300.0;
1159  TminPsat = 300.0;
1160 
1161  cRho.clear();
1162  cRho.push_back(+8.8355972263E+02);
1163  cRho.push_back(+4.0994176412E+00);
1164  cRho.push_back(-1.5309807839E-02);
1165  cRho.push_back(+1.7359111477E-05);
1166 
1167  cHeat.clear();
1168  cHeat.push_back(-5.1241354234E+02);
1169  cHeat.push_back(+2.3184299720E+01);
1170  cHeat.push_back(-3.7767937944E-02);
1171  cHeat.push_back(-1.2066365007E-06);
1172 
1173  cCond.clear();
1174  cCond.push_back(+1.3896631868E-01);
1175  cCond.push_back(+1.1308846154E-03);
1176  cCond.push_back(-6.0439560440E-08);
1177 
1178  cVisc.clear();
1179  cVisc.push_back(+4.7403455568E+02);
1180  cVisc.push_back(-1.6081056499E+02);
1181  cVisc.push_back(+9.4982567299E+00);
1182 
1183  cPsat.clear();
1184 
1185  };
1186 };
1187 
1188 class AS55Class : public SimpleIncompressible{
1189 public:
1190  AS55Class(){
1191 
1192  name = std::string("AS55");
1193  description = std::string("Aspen Temper -55");
1194  reference = std::string("SecCool Software");
1195 
1196  Tmin = 220.0;
1197  Tmax = 300.0;
1198  TminPsat = 300.0;
1199 
1200  cRho.clear();
1201  cRho.push_back(+8.9605196078E+02);
1202  cRho.push_back(+4.5156492948E+00);
1203  cRho.push_back(-1.7100103199E-02);
1204  cRho.push_back(+1.9435844513E-05);
1205 
1206  cHeat.clear();
1207  cHeat.push_back(+3.6600598555E+02);
1208  cHeat.push_back(+1.5792254902E+01);
1209  cHeat.push_back(-2.4545923633E-02);
1210  cHeat.push_back(-4.1279669761E-07);
1211 
1212  cCond.clear();
1213  cCond.push_back(+3.3985681115E-01);
1214  cCond.push_back(-3.0877966976E-04);
1215  cCond.push_back(+2.2822497420E-06);
1216 
1217  cVisc.clear();
1218  cVisc.push_back(+6.1353626424E+02);
1219  cVisc.push_back(-1.5081016752E+02);
1220  cVisc.push_back(+1.0109522524E+01);
1221 
1222  cPsat.clear();
1223 
1224  };
1225 };
1226 
1227 class ZS10Class : public SimpleIncompressible{
1228 public:
1229  ZS10Class(){
1230 
1231  name = std::string("ZS10");
1232  description = std::string("Zitrec S -10");
1233  reference = std::string("SecCool Software");
1234 
1235  Tmin = 265.0;
1236  Tmax = 360.0;
1237  TminPsat = 360.0;
1238 
1239  cRho.clear();
1240  cRho.push_back(+1.2314887434E+03);
1241  cRho.push_back(-5.2375274970E-01);
1242  cRho.push_back(+1.9728931723E-04);
1243  cRho.push_back(-2.1700379757E-07);
1244 
1245  cHeat.clear();
1246  cHeat.push_back(+2.2183875526E+03);
1247  cHeat.push_back(+7.4287485687E+00);
1248  cHeat.push_back(-9.1301807180E-03);
1249  cHeat.push_back(-1.7295039503E-07);
1250 
1251  cCond.clear();
1252  cCond.push_back(+1.2534548872E-01);
1253  cCond.push_back(+1.4936591479E-03);
1254  cCond.push_back(-3.0576441103E-07);
1255 
1256  cVisc.clear();
1257  cVisc.push_back(+5.2976289768E+02);
1258  cVisc.push_back(-1.5197832234E+02);
1259  cVisc.push_back(+1.0073901959E+01);
1260 
1261  cPsat.clear();
1262 
1263  };
1264 };
1265 
1266 class ZS25Class : public SimpleIncompressible{
1267 public:
1268  ZS25Class(){
1269 
1270  name = std::string("ZS25");
1271  description = std::string("Zitrec S -25");
1272  reference = std::string("SecCool Software");
1273 
1274  Tmin = 250.0;
1275  Tmax = 360.0;
1276  TminPsat = 360.0;
1277 
1278  cRho.clear();
1279  cRho.push_back(+1.3386515650E+03);
1280  cRho.push_back(-5.2656222039E-01);
1281  cRho.push_back(-1.5645224340E-05);
1282  cRho.push_back(+1.2161751291E-08);
1283 
1284  cHeat.clear();
1285  cHeat.push_back(+3.0812417591E+03);
1286  cHeat.push_back(+3.7786772648E-01);
1287  cHeat.push_back(-6.5881944143E-05);
1288  cHeat.push_back(+3.3242120199E-07);
1289 
1290  cCond.clear();
1291  cCond.push_back(+3.4681146245E-02);
1292  cCond.push_back(+1.9330395257E-03);
1293  cCond.push_back(-1.1992094862E-06);
1294 
1295  cVisc.clear();
1296  cVisc.push_back(+4.1761158398E+02);
1297  cVisc.push_back(-1.6295200411E+02);
1298  cVisc.push_back(+9.3205072397E+00);
1299 
1300  cPsat.clear();
1301 
1302  };
1303 };
1304 
1305 class ZS40Class : public SimpleIncompressible{
1306 public:
1307  ZS40Class(){
1308 
1309  name = std::string("ZS40");
1310  description = std::string("Zitrec S -40");
1311  reference = std::string("SecCool Software");
1312 
1313  Tmin = 235.0;
1314  Tmax = 360.0;
1315  TminPsat = 360.0;
1316 
1317  cRho.clear();
1318  cRho.push_back(+1.4183190376E+03);
1319  cRho.push_back(-5.8243188235E-01);
1320  cRho.push_back(+5.4922721789E-05);
1321  cRho.push_back(-6.5779076274E-08);
1322 
1323  cHeat.clear();
1324  cHeat.push_back(+9.5472807318E+02);
1325  cHeat.push_back(+1.6485063272E+01);
1326  cHeat.push_back(-5.3205833713E-02);
1327  cHeat.push_back(+6.2103990740E-05);
1328 
1329  cCond.clear();
1330  cCond.push_back(+1.5446717460E-01);
1331  cCond.push_back(+1.1457880342E-03);
1332  cCond.push_back(-1.5579975580E-07);
1333 
1334  cVisc.clear();
1335  cVisc.push_back(+4.6544465976E+02);
1336  cVisc.push_back(-1.5503900008E+02);
1337  cVisc.push_back(+9.2536810485E+00);
1338 
1339  cPsat.clear();
1340 
1341  };
1342 };
1343 
1344 class ZS45Class : public SimpleIncompressible{
1345 public:
1346  ZS45Class(){
1347 
1348  name = std::string("ZS45");
1349  description = std::string("Zitrec S -45");
1350  reference = std::string("SecCool Software");
1351 
1352  Tmin = 230.0;
1353  Tmax = 360.0;
1354  TminPsat = 360.0;
1355 
1356  cRho.clear();
1357  cRho.push_back(+1.4317629296E+03);
1358  cRho.push_back(-5.3989162562E-01);
1359  cRho.push_back(-4.2356111320E-05);
1360  cRho.push_back(+4.7155909223E-08);
1361 
1362  cHeat.clear();
1363  cHeat.push_back(+2.0449839861E+03);
1364  cHeat.push_back(+2.2070679223E+00);
1365  cHeat.push_back(-4.6369977429E-06);
1366  cHeat.push_back(+5.2395454720E-09);
1367 
1368  cCond.clear();
1369  cCond.push_back(+2.0207530462E-01);
1370  cCond.push_back(+8.0384160667E-04);
1371  cCond.push_back(+3.6382468107E-07);
1372 
1373  cVisc.clear();
1374  cVisc.push_back(+4.5803862071E+02);
1375  cVisc.push_back(-1.5592748501E+02);
1376  cVisc.push_back(+9.1329431082E+00);
1377 
1378  cPsat.clear();
1379 
1380  };
1381 };
1382 
1383 class ZS55Class : public SimpleIncompressible{
1384 public:
1385  ZS55Class(){
1386 
1387  name = std::string("ZS55");
1388  description = std::string("Zitrec S -55");
1389  reference = std::string("SecCool Software");
1390 
1391  Tmin = 220.0;
1392  Tmax = 360.0;
1393  TminPsat = 360.0;
1394 
1395  cRho.clear();
1396  cRho.push_back(+1.4861637422E+03);
1397  cRho.push_back(-5.7747246466E-01);
1398  cRho.push_back(-9.0036956000E-05);
1399  cRho.push_back(+9.9350655525E-08);
1400 
1401  cHeat.clear();
1402  cHeat.push_back(+2.3791157676E+03);
1403  cHeat.push_back(-7.7643011749E-01);
1404  cHeat.push_back(+4.7957532518E-03);
1405  cHeat.push_back(-6.3381598423E-08);
1406 
1407  cCond.clear();
1408  cCond.push_back(+2.4488072144E-01);
1409  cCond.push_back(+5.5666864417E-04);
1410  cCond.push_back(+5.3163126578E-07);
1411 
1412  cVisc.clear();
1413  cVisc.push_back(+5.0238871796E+02);
1414  cVisc.push_back(-1.5126152304E+02);
1415  cVisc.push_back(+9.1546618222E+00);
1416 
1417  cPsat.clear();
1418 
1419  };
1420 };
1421 
1422 #endif
HFELiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:280
SimpleIncompressible::h
double h(double T_K, double p)
Enthalpy as a function of temperature and pressure.
Definition: IncompLiquid.h:154
IncompressibleClass::polyfracint
double polyfracint(std::vector< double > const &coefficients, double T)
Definition: IncompBase.h:267
SimpleIncompressible::rho
double rho(double T_K, double p)
Density as a function of temperature and pressure.
Definition: IncompLiquid.h:146
IncompressibleClass
The base class for incompressible fluids only.
Definition: IncompBase.h:16
IncompressibleLiquid::testInputs
void testInputs(double T_K, double p)
Base class for simplified brine/solution models.
Definition: IncompLiquid.cpp:26
SimpleIncompressible::cPsat
std::vector< double > cPsat
Definition: IncompLiquid.h:143
TherminolD12Class
New fluids added with more coefficients.
Definition: IncompLiquid.h:469
PMS1LiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:313
SimpleIncompressible::cRho
std::vector< double > cRho
Definition: IncompLiquid.h:139
SimpleIncompressible::psat
double psat(double T_K)
Saturation pressure as a function of temperature.
Definition: IncompLiquid.h:173
IncompressibleLiquid::h_u
double h_u(double T_K, double p)
Enthalpy from u,p and rho.
Definition: IncompLiquid.h:62
IncompressibleClass::reference
std::string reference
Definition: IncompBase.h:21
IncompressibleLiquid::cv
virtual double cv(double T_K, double p)
Definition: IncompLiquid.h:36
IncompressibleLiquid::cp
virtual double cp(double T_K, double p)
Definition: IncompLiquid.h:35
IncompressibleLiquid
Base class for simplified brine/solution models.
Definition: IncompLiquid.h:25
HCMLiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:247
IncompressibleClass::polyint
double polyint(std::vector< double > const &coefficients, double T)
Definition: IncompBase.h:227
IncompressibleLiquid::u
virtual double u(double T_K, double p)
Internal energy as a function of temperature and pressure.
Definition: IncompLiquid.h:40
SABLiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:379
IncompressibleClass::description
std::string description
Definition: IncompBase.h:20
TCOLiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:445
SimpleIncompressible::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:162
format
std::string format(const char *fmt,...)
Definition: CoolPropTools.cpp:22
IncompressibleLiquid::rho
virtual double rho(double T_K, double p)
Density as a function of temperature and pressure.
Definition: IncompLiquid.h:32
SimpleIncompressible::cVisc
std::vector< double > cVisc
Definition: IncompLiquid.h:141
IncompressibleLiquid::checkT
bool checkT(double T_K)
Check validity of temperature input.
Definition: IncompLiquid.cpp:63
IncompressibleClass::expval
double expval(std::vector< double > const &coefficients, double T, int n)
Definition: IncompBase.cpp:812
IncompBase.h
SimpleIncompressible::cCond
std::vector< double > cCond
Definition: IncompLiquid.h:142
SimpleIncompressible
Base class for simplified models.
Definition: IncompLiquid.h:137
IncompressibleLiquid::s
virtual double s(double T_K, double p)
Entropy as a function of temperature and pressure.
Definition: IncompLiquid.h:38
SimpleIncompressible::u
double u(double T_K, double p)
Internal energy as a function of temperature and pressure.
Definition: IncompLiquid.h:170
IncompressibleLiquid::u_h
double u_h(double T_K, double p)
Internal energy from h,p and rho.
Definition: IncompLiquid.h:70
CoolPropTools.h
IsIncompressibleLiquid
bool IsIncompressibleLiquid(std::string name)
Definition: IncompLiquid.cpp:190
SimpleIncompressible::cond
double cond(double T_K, double p)
Thermal conductivity as a function of temperature and pressure.
Definition: IncompLiquid.h:166
SimpleIncompressible::c
double c(double T_K, double p)
Heat capacities as a function of temperature and pressure.
Definition: IncompLiquid.h:150
IncompressibleLiquid::c
virtual double c(double T_K, double p)
Heat capacities as a function of temperature and pressure.
Definition: IncompLiquid.h:34
IncompressibleLiquid::h
virtual double h(double T_K, double p)
Enthalpy as a function of temperature and pressure.
Definition: IncompLiquid.h:42
SimpleIncompressible::cHeat
std::vector< double > cHeat
Definition: IncompLiquid.h:140
IncompLiquidSI
double IncompLiquidSI(long iOutput, double T, double p, long iFluid)
Definition: IncompLiquid.cpp:250
IncompressibleLiquid::psat
virtual double psat(double T_K)
Saturation pressure as a function of temperature.
Definition: IncompLiquid.h:48
PMS2LiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:346
IncompressibleClass::polyval
double polyval(std::vector< double > const &coefficients, double x)
Definition: IncompBase.h:210
LiquidsContainer::get_liquid
IncompressibleLiquid * get_liquid(long index)
Definition: IncompLiquid.cpp:159
CPExceptions.h
LiquidsContainer::set_liquids
void set_liquids(std::vector< IncompressibleLiquid * > list)
Definition: IncompLiquid.cpp:178
IncompressibleLiquid::checkP
bool checkP(double T_K, double p)
Check validity of pressure input.
Definition: IncompLiquid.cpp:83
DEBLiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:214
IncompressibleClass::name
std::string name
Definition: IncompBase.h:19
SimpleIncompressible::s
double s(double T_K, double p)
Entropy as a function of temperature and pressure.
Definition: IncompLiquid.h:158
IncompressibleLiquid::cond
virtual double cond(double T_K, double p)
Thermal conductivity as a function of temperature and pressure.
Definition: IncompLiquid.h:46
HCBLiquidClass::visc
double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:412
IncompressibleLiquid::checkTP
bool checkTP(double T, double p)
Check validity of temperature and pressure input.
Definition: IncompLiquid.cpp:93
IncompressibleLiquid::visc
virtual double visc(double T_K, double p)
Viscosity as a function of temperature and pressure.
Definition: IncompLiquid.h:44
Generated on Sun Aug 10 2014 16:02:40 for CoolProp by   doxygen 1.8.7