antioch-0.4.0
Functions
stat_mech_thermo_unit.C File Reference
#include <cmath>
#include <limits>
#include "antioch/vector_utils_decl.h"
#include "antioch/physical_constants.h"
#include "antioch/chemical_mixture.h"
#include "antioch/stat_mech_thermo.h"
#include "antioch/vector_utils.h"

Go to the source code of this file.

Functions

template<typename Scalar >
bool test_relative (const Scalar val, const Scalar truth, const Scalar tol)
 
template<typename Scalar >
bool test_zero (const Scalar val, const Scalar tol)
 
template<typename Scalar >
int test_cv_tr ()
 
template<typename Scalar >
int test_cv_vib ()
 
template<typename Scalar >
Scalar cv_el_compare (const unsigned int g[], const Scalar theta[], const Scalar Rs, const Scalar Te, unsigned int N)
 
template<typename Scalar >
int test_cv_el ()
 
template<typename Scalar >
int test_T_from_e_tot ()
 
int main ()
 

Function Documentation

template<typename Scalar >
Scalar cv_el_compare ( const unsigned int  g[],
const Scalar  theta[],
const Scalar  Rs,
const Scalar  Te,
unsigned int  N 
)

Definition at line 392 of file stat_mech_thermo_unit.C.

Referenced by test_cv_el().

394 {
395  using std::exp;
396 
397  Scalar cv=0.0;
398 
399  Scalar num=0.0, den=0.0, dnum=0.0, dden=0.0;
400 
401  for (unsigned int i=0; i<N; ++i)
402  {
403  num += theta[i]*static_cast<Scalar>(g[i])*exp(-theta[i]/Te);
404  dnum += theta[i]*static_cast<Scalar>(g[i])*exp(-theta[i]/Te)*(theta[i]/Te/Te);
405 
406  den += static_cast<Scalar>(g[i])*exp(-theta[i]/Te);
407  dden += static_cast<Scalar>(g[i])*exp(-theta[i]/Te)*(theta[i]/Te/Te);
408  }
409 
410  cv = Rs*(dnum/den - num*dden/den/den);
411 
412  return cv;
413 }
g
Scalar g(const std::vector< Scalar > &thermo, const Scalar &T)
Definition: kinetics_partial_order_unit.C:204
int main ( )

Definition at line 630 of file stat_mech_thermo_unit.C.

631 {
632 
633  // Translational/rotational specific heat at constant volume
634  int ierr = (test_cv_tr<double>() ||
635 // test_cv_tr<long double>() ||
636  test_cv_tr<float>());
637 
638  // Vibrational specific heat at constant volume
639  ierr += (test_cv_vib<double>() ||
640 // test_cv_vib<long double>() ||
641  test_cv_vib<float>());
642 
643  // Electronic specific heat at constant volume
644  ierr += (test_cv_el<double>() ||
645 // test_cv_el<long double>() ||
646  test_cv_el<float>());
647 
648  // Consistency of T_from_e_tot
649  ierr += (test_T_from_e_tot<double>() ||
650 // test_T_from_e_tot<long double>() ||
651  test_T_from_e_tot<float>());
652 
653  return ierr;
654 }
template<typename Scalar >
int test_cv_el ( )

Definition at line 416 of file stat_mech_thermo_unit.C.

References Antioch::StatMechThermodynamics< CoeffType >::cv_el(), cv_el_compare(), and test_relative().

417 {
418  using std::exp;
419  const Scalar Mm_O = 16.e-3L; // SI kg/mol
420  const Scalar Mm_O2 = 2.L * Mm_O; // SI kg/mol
421 
422  std::vector<std::string> species_str_list;
423  const unsigned int n_species = 2;
424  species_str_list.reserve(n_species);
425  species_str_list.push_back( "O2" );
426  species_str_list.push_back( "O" );
427 
428  Antioch::ChemicalMixture<Scalar> chem_mixture( species_str_list );
429 
430  // Can we instantiate it?
431  Antioch::StatMechThermodynamics<Scalar> sm_thermo( chem_mixture );
432 
433  // Mass fractions
434  std::vector<Scalar> mass_fractions( n_species, 0.2 );
435  mass_fractions[0] = 0.9;
436  mass_fractions[1] = 0.1;
437 
438  const Scalar R_O2 = Antioch::Constants::R_universal<Scalar>() / Mm_O2;
439  const Scalar R_O = Antioch::Constants::R_universal<Scalar>() / Mm_O;
440 
441  // Data taken from read_species_electronic_data_ascii_default
442  unsigned int g_O[5] = {5, 3, 1, 5, 1};
443  Scalar theta_O[5] = {0.00000e+00,
444  2.27708e+02,
445  3.26569e+02,
446  2.28303e+04,
447  4.86199e+04};
448 
449  unsigned int g_O2[7] = {3, 2, 1, 1, 6, 3, 3};
450  Scalar theta_O2[7] = {0.00000e+00,
451  1.13916e+04,
452  1.89847e+04,
453  4.75597e+04,
454  4.99124e+04,
455  5.09227e+04,
456  7.18986e+04};
457  // Te
458  const Scalar Te = 1000.0;
459 
460  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 8;
461 
462  Scalar cv_el_mix_true = 0.0;
463 
464  int return_flag = 0;
465 
466  // O2
467  {
468  Scalar cv_el_O2 = sm_thermo.cv_el (0, Te);
469  Scalar cv_el_O2_true = cv_el_compare(g_O2, theta_O2, R_O2, Te, 7);
470 
471  if( !test_relative(cv_el_O2, cv_el_O2_true, tol) )
472  {
473  std::cerr << std::scientific << std::setprecision(20);
474  std::cerr << "Error: Mismatch in cv_el for O2."
475  << "\n Expected = " << cv_el_O2_true
476  << "\n Computed = " << cv_el_O2
477  << "\n Diff = " << cv_el_O2_true - cv_el_O2
478  << "\n Tol = " << tol
479  << std::endl;
480  return_flag += 1;
481  }
482 
483  cv_el_mix_true += mass_fractions[0]*cv_el_O2_true;
484  }
485 
486  // O
487  {
488  Scalar cv_el_O = sm_thermo.cv_el (1, Te);
489  Scalar cv_el_O_true = cv_el_compare(g_O, theta_O, R_O, Te, 5);
490 
491  if( !test_relative(cv_el_O, cv_el_O_true, tol) )
492  {
493  std::cerr << std::scientific << std::setprecision(20);
494  std::cerr << "Error: Mismatch in cv_el for O."
495  << "\n Expected = " << cv_el_O_true
496  << "\n Computed = " << cv_el_O
497  << "\n Diff = " << cv_el_O_true - cv_el_O
498  << "\n Tol = " << tol
499  << std::endl;
500  return_flag += 1;
501  }
502 
503  cv_el_mix_true += mass_fractions[1]*cv_el_O_true;
504  }
505 
506  // Mixture
507  {
508  Scalar cv_el = sm_thermo.cv_el (Te, mass_fractions);
509 
510  if( !test_relative(cv_el, cv_el_mix_true, tol) )
511  {
512  std::cerr << std::scientific << std::setprecision(20);
513  std::cerr << "Error: Mismatch in cv_el for mixture."
514  << "\n Expected = " << cv_el_mix_true
515  << "\n Computed = " << cv_el
516  << "\n Diff = " << cv_el_mix_true - cv_el
517  << "\n Tol = " << tol
518  << std::endl;
519  return_flag += 1;
520  }
521  }
522 
523  return return_flag;
524 }
test_relative
bool test_relative(const Scalar val, const Scalar truth, const Scalar tol)
Definition: stat_mech_thermo_unit.C:46
cv_el_compare
Scalar cv_el_compare(const unsigned int g[], const Scalar theta[], const Scalar Rs, const Scalar Te, unsigned int N)
Definition: stat_mech_thermo_unit.C:392
Antioch::ChemicalMixture
Class storing chemical mixture properties.
Definition: chemical_mixture.h:75
template<typename Scalar >
int test_cv_tr ( )

Definition at line 68 of file stat_mech_thermo_unit.C.

References Antioch::StatMechThermodynamics< CoeffType >::cv_tr(), and test_relative().

69 {
70  const Scalar Mm_N = 14.008e-3; //in SI kg/mol
71  const Scalar Mm_O = 16e-3; //in SI kg/mol
72  const Scalar Mm_N2 = 2.L * Mm_N; //in SI kg/mol
73  const Scalar Mm_O2 = 2.L * Mm_O; //in SI kg/mol
74  const Scalar Mm_NO = Mm_O + Mm_N; //in SI kg/mol
75 
76  std::vector<std::string> species_str_list;
77  const unsigned int n_species = 5;
78  species_str_list.reserve(n_species);
79  species_str_list.push_back( "N2" );
80  species_str_list.push_back( "O2" );
81  species_str_list.push_back( "N" );
82  species_str_list.push_back( "O" );
83  species_str_list.push_back( "NO" );
84 
85  Antioch::ChemicalMixture<Scalar> chem_mixture( species_str_list );
86 
87  // Can we instantiate it?
88  Antioch::StatMechThermodynamics<Scalar> sm_thermo( chem_mixture );
89 
90  // Mass fractions
91  std::vector<Scalar> mass_fractions( 5, 0.2 );
92  mass_fractions[0] = 0.5;
93  mass_fractions[1] = 0.2;
94  mass_fractions[2] = 0.1;
95  mass_fractions[3] = 0.1;
96  mass_fractions[4] = 0.1;
97 
98  Scalar cv_tr_mix = 0.0;
99 
100  const Scalar R_N2 = Antioch::Constants::R_universal<Scalar>() / Mm_N2;
101  const Scalar R_O2 = Antioch::Constants::R_universal<Scalar>() / Mm_O2;
102  const Scalar R_N = Antioch::Constants::R_universal<Scalar>() / Mm_N;
103  const Scalar R_O = Antioch::Constants::R_universal<Scalar>() / Mm_O;
104  const Scalar R_NO = Antioch::Constants::R_universal<Scalar>() / Mm_NO;
105 
106  int return_flag = 0;
107 
108  Scalar tol = std::numeric_limits<Scalar>::epsilon() * 2;
109 
110  // N2
111  {
112  Scalar cv_N2 = sm_thermo.cv_tr(0);
113 
114  if( !test_relative(cv_N2, R_N2*Scalar(2.5), tol) )
115  {
116  std::cerr << std::scientific << std::setprecision(20);
117  std::cerr << "Error: Mismatch in cv_tr for N2."
118  << "\n Expected = " << R_N2*Scalar(2.5)
119  << "\n Computed = " << cv_N2
120  << "\n Diff = " << cv_N2 - R_N2*Scalar(2.5)
121  << std::endl;
122  return_flag += 1;
123  }
124 
125  cv_tr_mix += cv_N2*mass_fractions[0];
126  }
127 
128  // O2
129  {
130  Scalar cv_O2 = sm_thermo.cv_tr(1);
131 
132  if( !test_relative(cv_O2, R_O2*Scalar(2.5), tol) )
133  {
134  std::cerr << std::scientific << std::setprecision(20);
135  std::cerr << "Error: Mismatch in cv_tr for O2."
136  << "\n Expected = " << R_O2*Scalar(2.5)
137  << "\n Computed = " << cv_O2
138  << "\n Diff = " << cv_O2 - R_O2*Scalar(2.5)
139  << std::endl;
140  return_flag += 1;
141  }
142 
143  cv_tr_mix += cv_O2*mass_fractions[1];
144  }
145 
146  // N
147  {
148  Scalar cv_N = sm_thermo.cv_tr(2);
149 
150  if( !test_relative(cv_N, R_N*Scalar(1.5), tol) )
151  {
152  std::cerr << std::scientific << std::setprecision(20);
153  std::cerr << "Error: Mismatch in cv_tr for N."
154  << "\n Expected = " << R_N*Scalar(1.5)
155  << "\n Computed = " << cv_N
156  << "\n Diff = " << cv_N - R_N*Scalar(2.5)
157  << std::endl;
158  return_flag += 1;
159  }
160 
161  cv_tr_mix += cv_N*mass_fractions[2];
162  }
163 
164  // O
165  {
166  Scalar cv_O = sm_thermo.cv_tr(3);
167 
168  if( !test_relative(cv_O, R_O*Scalar(1.5), tol) )
169  {
170  std::cerr << std::scientific << std::setprecision(20);
171  std::cerr << "Error: Mismatch in cv_tr for O."
172  << "\n Expected = " << R_O*Scalar(1.5)
173  << "\n Computed = " << cv_O
174  << "\n Diff = " << cv_O - R_O*Scalar(2.5)
175  << std::endl;
176  return_flag += 1;
177  }
178 
179  cv_tr_mix += cv_O*mass_fractions[3];
180  }
181 
182  // NO
183  {
184  Scalar cv_NO = sm_thermo.cv_tr(4);
185 
186  if( !test_relative(cv_NO, R_NO*Scalar(2.5), tol) )
187  {
188  std::cerr << std::scientific << std::setprecision(20);
189  std::cerr << "Error: Mismatch in cv_tr for NO."
190  << "\n Expected = " << R_NO*Scalar(2.5)
191  << "\n Computed = " << cv_NO
192  << "\n Diff = " << cv_NO - R_NO*Scalar(2.5)
193  << std::endl;
194  return_flag += 1;
195  }
196 
197  cv_tr_mix += cv_NO*mass_fractions[4];
198  }
199 
200  // mixture
201  {
202  Scalar cv = sm_thermo.cv_tr(mass_fractions);
203 
204  if( !test_relative(cv, cv_tr_mix, tol) )
205  {
206  std::cerr << std::scientific << std::setprecision(20);
207  std::cerr << "Error: Mismatch in mixture cv_tr."
208  << "\n Expected = " << cv_tr_mix
209  << "\n Computed = " << cv
210  << "\n Diff = " << cv - cv_tr_mix
211  << std::endl;
212  return_flag += 1;
213  }
214  }
215 
216  return return_flag;
217 }
test_relative
bool test_relative(const Scalar val, const Scalar truth, const Scalar tol)
Definition: stat_mech_thermo_unit.C:46
Antioch::ChemicalMixture
Class storing chemical mixture properties.
Definition: chemical_mixture.h:75
template<typename Scalar >
int test_cv_vib ( )

Definition at line 220 of file stat_mech_thermo_unit.C.

References Antioch::StatMechThermodynamics< CoeffType >::cv_vib(), test_relative(), and test_zero().

221 {
222  using std::exp;
223 
224  const Scalar Mm_N = 14.008e-3; //in SI kg/mol
225  const Scalar Mm_O = 16e-3; //in SI kg/mol
226  const Scalar Mm_N2 = 2.L * Mm_N; //in SI kg/mol
227  const Scalar Mm_O2 = 2.L * Mm_O; //in SI kg/mol
228  const Scalar Mm_NO = Mm_O + Mm_N; //in SI kg/mol
229 
230  std::vector<std::string> species_str_list;
231  const unsigned int n_species = 5;
232  species_str_list.reserve(n_species);
233  species_str_list.push_back( "N2" );
234  species_str_list.push_back( "O2" );
235  species_str_list.push_back( "N" );
236  species_str_list.push_back( "O" );
237  species_str_list.push_back( "NO" );
238 
239  Antioch::ChemicalMixture<Scalar> chem_mixture( species_str_list );
240 
241  // Can we instantiate it?
242  Antioch::StatMechThermodynamics<Scalar> sm_thermo( chem_mixture );
243 
244  // Mass fractions
245  std::vector<Scalar> mass_fractions( 5, 0.2 );
246  mass_fractions[0] = 0.5;
247  mass_fractions[1] = 0.2;
248  mass_fractions[2] = 0.1;
249  mass_fractions[3] = 0.1;
250  mass_fractions[4] = 0.1;
251 
252  const Scalar R_N2 = Antioch::Constants::R_universal<Scalar>() / Mm_N2;
253  const Scalar R_O2 = Antioch::Constants::R_universal<Scalar>() / Mm_O2;
254  const Scalar R_NO = Antioch::Constants::R_universal<Scalar>() / Mm_NO;
255 
256  const Scalar th0_N2 = 3.39500e+03; // degeneracy = 1
257  const Scalar th0_O2 = 2.23900e+03; // degeneracy = 1
258  const Scalar th0_NO = 2.81700e+03; // degeneracy = 1
259 
260  // Tv
261  const Scalar Tv = 1000.0;
262 
263  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 2;
264  const Scalar ztol = std::numeric_limits<Scalar>::epsilon();
265 
266  int return_flag = 0;
267 
268  Scalar cv_vib_mix = 0.0;
269 
270  // N2
271  {
272  Scalar cv_vib_N2 = sm_thermo.cv_vib (0, Tv);
273 
274  const Scalar expv = exp(th0_N2/Tv);
275  const Scalar expvmi = expv - Scalar(1.0);
276  Scalar cv_vib_N2_true = R_N2*th0_N2*th0_N2*expv/expvmi/expvmi/Tv/Tv;
277 
278  if( !test_relative(cv_vib_N2, cv_vib_N2_true, tol) )
279  {
280  std::cerr << std::scientific << std::setprecision(20);
281  std::cerr << "Error: Mismatch in cv_vib for N2."
282  << "\n Expected = " << cv_vib_N2_true
283  << "\n Computed = " << cv_vib_N2
284  << "\n Diff = " << cv_vib_N2_true - cv_vib_N2
285  << std::endl;
286  return_flag += 1;
287  }
288 
289  cv_vib_mix += mass_fractions[0]*cv_vib_N2_true;
290  }
291 
292  // O2
293  {
294  Scalar cv_vib_O2 = sm_thermo.cv_vib (1, Tv);
295 
296  const Scalar expv = exp(th0_O2/Tv);
297  const Scalar expvmi = expv - Scalar(1.0);
298  Scalar cv_vib_O2_true = R_O2*th0_O2*th0_O2*expv/expvmi/expvmi/Tv/Tv;
299 
300  if( !test_relative(cv_vib_O2, cv_vib_O2_true, tol) )
301  {
302  std::cerr << std::scientific << std::setprecision(20);
303  std::cerr << "Error: Mismatch in cv_vib for O2."
304  << "\n Expected = " << cv_vib_O2_true
305  << "\n Computed = " << cv_vib_O2
306  << "\n Diff = " << cv_vib_O2_true - cv_vib_O2
307  << std::endl;
308  return_flag += 1;
309  }
310 
311  cv_vib_mix += mass_fractions[1]*cv_vib_O2_true;
312  }
313 
314  // O
315  {
316  Scalar cv_vib_O = sm_thermo.cv_vib (2, Tv);
317 
318  if( !test_zero(cv_vib_O, ztol) )
319  {
320  std::cerr << std::scientific << std::setprecision(20);
321  std::cerr << "Error: Mismatch in cv_vib for O."
322  << "\n Expected = " << Scalar(0.0)
323  << "\n Computed = " << cv_vib_O
324  << "\n Diff = " << cv_vib_O
325  << std::endl;
326  return_flag += 1;
327  }
328 
329  // cv_vib_mix += 0.0;
330  }
331 
332  // N
333  {
334  Scalar cv_vib_N = sm_thermo.cv_vib (3, Tv);
335 
336  if( !test_zero(cv_vib_N, ztol) )
337  {
338  std::cerr << std::scientific << std::setprecision(20);
339  std::cerr << "Error: Mismatch in cv_vib for N."
340  << "\n Expected = " << Scalar(0.0)
341  << "\n Computed = " << cv_vib_N
342  << "\n Diff = " << cv_vib_N
343  << std::endl;
344  return_flag += 1;
345  }
346 
347  // cv_vib_mix += 0.0;
348  }
349 
350  // NO
351  {
352  Scalar cv_vib_NO = sm_thermo.cv_vib (4, Tv);
353 
354  const Scalar expv = exp(th0_NO/Tv);
355  const Scalar expvmi = expv - Scalar(1.0);
356  Scalar cv_vib_NO_true = R_NO*th0_NO*th0_NO*expv/expvmi/expvmi/Tv/Tv;
357 
358  if( !test_relative(cv_vib_NO, cv_vib_NO_true, tol*4) )
359  {
360  std::cerr << std::scientific << std::setprecision(20);
361  std::cerr << "Error: Mismatch in cv_vib for NO."
362  << "\n Expected = " << cv_vib_NO_true
363  << "\n Computed = " << cv_vib_NO
364  << "\n Diff = " << cv_vib_NO_true - cv_vib_NO
365  << std::endl;
366  return_flag += 1;
367  }
368 
369  cv_vib_mix += mass_fractions[4]*cv_vib_NO_true;
370  }
371 
372  // mixture
373  {
374  Scalar cv = sm_thermo.cv_vib(Tv, mass_fractions);
375 
376  if( !test_relative(cv, cv_vib_mix, tol) )
377  {
378  std::cerr << std::scientific << std::setprecision(20);
379  std::cerr << "Error: Mismatch in mixture cv_vib."
380  << "\n Expected = " << cv_vib_mix
381  << "\n Computed = " << cv
382  << "\n Diff = " << cv - cv_vib_mix
383  << std::endl;
384  return_flag += 1;
385  }
386  }
387 
388  return return_flag;
389 }
test_relative
bool test_relative(const Scalar val, const Scalar truth, const Scalar tol)
Definition: stat_mech_thermo_unit.C:46
test_zero
bool test_zero(const Scalar val, const Scalar tol)
Definition: stat_mech_thermo_unit.C:57
Antioch::ChemicalMixture
Class storing chemical mixture properties.
Definition: chemical_mixture.h:75
template<typename Scalar >
bool test_relative ( const Scalar  val,
const Scalar  truth,
const Scalar  tol 
)

Definition at line 46 of file stat_mech_thermo_unit.C.

Referenced by test_cv_el(), test_cv_tr(), test_cv_vib(), and test_T_from_e_tot().

47 {
48  using std::abs;
49 
50  if( abs( (val-truth)/truth ) > tol )
51  return false;
52  else
53  return true;
54 }
template<typename Scalar >
int test_T_from_e_tot ( )

Definition at line 528 of file stat_mech_thermo_unit.C.

References Antioch::StatMechThermodynamics< CoeffType >::e_tot(), Antioch::StatMechThermodynamics< CoeffType >::T_from_e_tot(), and test_relative().

529 {
530  std::vector<std::string> species_str_list;
531  const unsigned int n_species = 5;
532  species_str_list.reserve(n_species);
533  species_str_list.push_back( "N2" );
534  species_str_list.push_back( "O2" );
535  species_str_list.push_back( "N" );
536  species_str_list.push_back( "O" );
537  species_str_list.push_back( "NO" );
538 
539  Antioch::ChemicalMixture<Scalar> chem_mixture( species_str_list );
540 
541  // Can we instantiate it?
542  Antioch::StatMechThermodynamics<Scalar> sm_thermo( chem_mixture );
543 
544  // Mass fractions
545  std::vector<Scalar> mass_fractions( 5, 0.2 );
546  mass_fractions[0] = 0.5;
547  mass_fractions[1] = 0.2;
548  mass_fractions[2] = 0.1;
549  mass_fractions[3] = 0.1;
550  mass_fractions[4] = 0.1;
551 
552  int return_flag = 0;
553 
554  // NOTE: Relatively larger tolerance here due to tolerance on Newton
555  // iteration for T.
556  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 100;
557 
558  // low T
559  {
560  const Scalar Texact = 300.0;
561 
562  // compute e_tot
563  const Scalar e_tot = sm_thermo.e_tot(Texact, mass_fractions);
564 
565  // compute T from e_tot (not providing initial guess)
566  const Scalar T = sm_thermo.T_from_e_tot(e_tot, mass_fractions);
567 
568  if( !test_relative(T, Texact, tol) )
569  {
570  std::cerr << std::scientific << std::setprecision(20);
571  std::cerr << "Error: Mismatch in T_from_e_tot."
572  << "\n Expected = " << Texact
573  << "\n Computed = " << T
574  << "\n Diff = " << Texact - T
575  << "\n Tol = " << tol
576  << std::endl;
577  return_flag += 1;
578  }
579  }
580 
581  // mid T
582  {
583  const Scalar Texact = 1000.0;
584 
585  // compute e_tot
586  const Scalar e_tot = sm_thermo.e_tot(Texact, mass_fractions);
587 
588  // compute T from e_tot (not providing initial guess)
589  const Scalar T = sm_thermo.T_from_e_tot(e_tot, mass_fractions);
590 
591  if( !test_relative(T, Texact, tol) )
592  {
593  std::cerr << std::scientific << std::setprecision(20);
594  std::cerr << "Error: Mismatch in T_from_e_tot."
595  << "\n Expected = " << Texact
596  << "\n Computed = " << T
597  << "\n Diff = " << Texact - T
598  << "\n Tol = " << tol
599  << std::endl;
600  return_flag += 1;
601  }
602  }
603 
604  // high T
605  {
606  const Scalar Texact = 5010.0;
607 
608  // compute e_tot
609  const Scalar e_tot = sm_thermo.e_tot(Texact, mass_fractions);
610 
611  // compute T from e_tot (not providing initial guess)
612  const Scalar T = sm_thermo.T_from_e_tot(e_tot, mass_fractions);
613 
614  if( !test_relative(T, Texact, tol) )
615  {
616  std::cerr << std::scientific << std::setprecision(20);
617  std::cerr << "Error: Mismatch in T_from_e_tot."
618  << "\n Expected = " << Texact
619  << "\n Computed = " << T
620  << "\n Diff = " << Texact - T
621  << "\n Tol = " << tol
622  << std::endl;
623  return_flag += 1;
624  }
625  }
626 
627  return return_flag;
628 }
test_relative
bool test_relative(const Scalar val, const Scalar truth, const Scalar tol)
Definition: stat_mech_thermo_unit.C:46
Antioch::ChemicalMixture
Class storing chemical mixture properties.
Definition: chemical_mixture.h:75
template<typename Scalar >
bool test_zero ( const Scalar  val,
const Scalar  tol 
)

Definition at line 57 of file stat_mech_thermo_unit.C.

Referenced by test_cv_vib().

58 {
59  using std::abs;
60 
61  if( abs(val) > tol )
62  return false;
63  else
64  return true;
65 }
Generated on Thu Jul 7 2016 11:09:48 for antioch-0.4.0 by  doxygen 1.8.8