#include <ascii_parser.h>

Classes
class	Cache

Public Member Functions
	CEAThermodynamics (const ChemicalMixture< CoeffType > &chem_mixture, const std::string &filename=DefaultFilename::thermo_data())

virtual	~CEAThermodynamics ()
	Destructor. More...

void	add_curve_fit (const std::string &species_name, const std::vector< CoeffType > &coeffs)

void	add_curve_fit (const std::string &species_name, const std::vector< CoeffType > &coeffs, const std::vector< CoeffType > &)

bool	check () const
	Checks that curve fits have been specified for all species in the mixture. More...

template<typename StateType >
StateType	cp (const Cache< StateType > &cache, unsigned int species) const
	We currently need different specializations for scalar vs vector inputs here. More...

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, StateType >::type	cp (const Cache< StateType > &cache, const VectorStateType &mass_fractions) const

template<typename StateType >
StateType	cv (const Cache< StateType > &cache, unsigned int species) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, StateType >::type	cv (const Cache< StateType > &cache, const VectorStateType &mass_fractions) const

template<typename StateType >
StateType	h (const Cache< StateType > &cache, unsigned int species) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	h (const Cache< StateType > &cache, VectorStateType &h) const

template<typename StateType >
StateType	h_RT_minus_s_R (const Cache< StateType > &cache, unsigned int species) const
	We currently need different specializations for scalar vs vector inputs here. More...

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	h_RT_minus_s_R (const Cache< StateType > &cache, VectorStateType &h_RT_minus_s_R) const

template<typename StateType >
StateType	dh_RT_minus_s_R_dT (const Cache< StateType > &cache, unsigned int species) const
	We currently need different specializations for scalar vs vector inputs here. More...

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	dh_RT_minus_s_R_dT (const Cache< StateType > &cache, VectorStateType &dh_RT_minus_s_R_dT) const

template<typename StateType >
StateType	cp_over_R (const Cache< StateType > &cache, unsigned int species) const

template<typename StateType >
StateType	h_over_RT (const Cache< StateType > &cache, unsigned int species) const

template<typename StateType >
StateType	s_over_R (const Cache< StateType > &cache, unsigned int species) const

const ChemicalMixture < CoeffType > &	chemical_mixture () const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, StateType >::type	cp (const Cache< StateType > &cache, const VectorStateType &mass_fractions) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	h (const Cache< StateType > &cache, VectorStateType &h) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	h_RT_minus_s_R (const Cache< StateType > &cache, VectorStateType &h_RT_minus_s_R) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, void >::type	dh_RT_minus_s_R_dT (const Cache< StateType > &cache, VectorStateType &dh_RT_minus_s_R_dT) const

template<typename StateType , typename VectorStateType >
enable_if_c< has_size < VectorStateType >::value, StateType >::type	cv (const Cache< StateType > &cache, const VectorStateType &mass_fractions) const

Protected Attributes
const ChemicalMixture < CoeffType > &	_chem_mixture

std::vector< CEACurveFit < CoeffType > * >	_species_curve_fits

std::vector< CoeffType >	_cp_at_200p1

Private Member Functions
	CEAThermodynamics ()
	Default constructor. More...

Detailed Description

template<typename CoeffType = double>
class Antioch::CEAThermodynamics< CoeffType >

Definition at line 75 of file ascii_parser.h.

Constructor & Destructor Documentation

template<typename CoeffType >

Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics	(	const ChemicalMixture< CoeffType > &	chem_mixture,
		const std::string &	filename = `DefaultFilename::thermo_data()`
	)

inline

deprecated

Definition at line 186 of file cea_thermo.h.

References Antioch::CEAThermodynamics< CoeffType >::_cp_at_200p1, Antioch::CEAThermodynamics< CoeffType >::_species_curve_fits, antioch_deprecated, Antioch::CEAThermodynamics< CoeffType >::cp(), and Antioch::read_cea_mixture_data_ascii().

     : _chem_mixture(chem_mixture),
       _species_curve_fits(chem_mixture.n_species(), NULL)
   {
 
  // should not use this object
      antioch_deprecated();
 
     // Read in CEA coefficients. Note this assumes chem_mixture is fully constructed.
     read_cea_mixture_data_ascii(*this, filename);
 
     // Cache cp values at small temperatures
     _cp_at_200p1.reserve( _species_curve_fits.size() );
     for( unsigned int s = 0; s < _species_curve_fits.size(); s++ )
       {
         _cp_at_200p1.push_back(CoeffType(0));
         _cp_at_200p1[s] = this->cp( Cache<CoeffType>(200.1), s );
       }
 
     return;
   }

template<typename CoeffType >

Antioch::CEAThermodynamics< CoeffType >::~CEAThermodynamics ( )

inlinevirtual

Destructor.

virtual so this can be subclassed by the user.

Definition at line 212 of file cea_thermo.h.

   {
     // Clean up all the CEACurveFits we created
     for( typename std::vector<CEACurveFit<CoeffType>* >::iterator it = _species_curve_fits.begin();
          it < _species_curve_fits.end(); ++it )
       {
         delete (*it);
       }
 
     return;
   }

template<typename CoeffType = double>

Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics ( )

private

Default constructor.

Private to force to user to supply a ChemicalMixture object.

Member Function Documentation

template<typename CoeffType >

void Antioch::CEAThermodynamics< CoeffType >::add_curve_fit	(	const std::string &	species_name,
		const std::vector< CoeffType > &	coeffs
	)

inline

Definition at line 227 of file cea_thermo.h.

References antioch_assert, and antioch_assert_less_equal.

Referenced by Antioch::CEAThermodynamics< CoeffType >::add_curve_fit(), Antioch::read_cea_thermo_data_ascii(), and Antioch::ASCIIParser< NumericType >::read_thermodynamic_data().

   {
     antioch_assert( _chem_mixture.species_name_map().find(species_name) !=
                     _chem_mixture.species_name_map().end() );
 
     unsigned int s = _chem_mixture.species_name_map().find(species_name)->second;
 
     antioch_assert_less_equal( s, _species_curve_fits.size() );
     antioch_assert( !_species_curve_fits[s] );
 
     _species_curve_fits[s] = new CEACurveFit<CoeffType>(coeffs);
     return;
   }

template<typename CoeffType = double>

void Antioch::CEAThermodynamics< CoeffType >::add_curve_fit	(	const std::string &	species_name,
		const std::vector< CoeffType > &	coeffs,
		const std::vector< CoeffType > &
	)

inline

Definition at line 95 of file cea_thermo.h.

References Antioch::CEAThermodynamics< CoeffType >::add_curve_fit().

96 {this->add_curve_fit(species_name,coeffs);}

Antioch::CEAThermodynamics::add_curve_fit

void add_curve_fit(const std::string &species_name, const std::vector< CoeffType > &coeffs)

Definition: cea_thermo.h:227

template<typename CoeffType >

bool Antioch::CEAThermodynamics< CoeffType >::check ( ) const

inline

Checks that curve fits have been specified for all species in the mixture.

Definition at line 245 of file cea_thermo.h.

Referenced by Antioch::read_cea_thermo_data_ascii().

   {
     bool valid = true;
 
     for( typename std::vector<CEACurveFit<CoeffType>* >::const_iterator it = _species_curve_fits.begin();
          it != _species_curve_fits.end(); ++ it )
       {
         if( !(*it) )
           valid = false;
       }
 
     return valid;
   }

template<typename CoeffType >

const ChemicalMixture< CoeffType > & Antioch::CEAThermodynamics< CoeffType >::chemical_mixture ( ) const

inline

Definition at line 572 of file cea_thermo.h.

Referenced by Antioch::read_cea_thermo_data_ascii(), and Antioch::ASCIIParser< NumericType >::read_thermodynamic_data().

   {
     return _chem_mixture;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::cp	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

We currently need different specializations for scalar vs vector inputs here.

Definition at line 264 of file cea_thermo.h.

References Antioch::constant_clone(), Antioch::if_else(), and Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T.

Referenced by Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics(), and test_cp().

   {
     typedef typename Antioch::value_type<StateType>::type ScalarType;
 
     // T < 200.1 ? cp_at_200p1 : R * cp_over_R
     return
       Antioch::if_else
         (cache.T < ScalarType(200.1),
          Antioch::constant_clone
            (cache.T,_cp_at_200p1[species]),
          StateType
            (this->_chem_mixture.R(species) *
             this->cp_over_R(cache, species)));
   }

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, StateType >::type Antioch::CEAThermodynamics< CoeffType >::cp	(	const Cache< StateType > &	cache,
		const VectorStateType &	mass_fractions
	)		const

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, StateType >::type Antioch::CEAThermodynamics< CoeffType >::cp	(	const Cache< StateType > &	cache,
		const VectorStateType &	mass_fractions
	)		const

inline

Definition at line 286 of file cea_thermo.h.

References antioch_assert_equal_to, antioch_assert_greater, and cp().

   {
     antioch_assert_equal_to( mass_fractions.size(), _species_curve_fits.size() );
     antioch_assert_greater( mass_fractions.size(), 0 );
 
     StateType cp = mass_fractions[0]*this->cp(cache,0);
 
     for( unsigned int s = 1; s < _species_curve_fits.size(); s++ )
       {
         cp += mass_fractions[s]*this->cp(cache,s);
       }
 
     return cp;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::cp_over_R	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

Definition at line 335 of file cea_thermo.h.

References antioch_assert_less, Antioch::if_else(), Antioch::max(), Antioch::min(), Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T2, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T3, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T4, and Antioch::zero_clone().

   {
     antioch_assert_less( species, _species_curve_fits.size() );
     // FIXME - we need assert_less to be vectorizable
     // antioch_assert_less( _species_curve_fits[species]->interval(cache.T),
     //                      _species_curve_fits[species]->n_intervals() );
 
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->_species_curve_fits[species]->interval(cache.T);
 
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     // FIXME - this needs expression templates to be faster...
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     /* cp/R =  a0*T^-2   + a1*T^-1     + a2     + a3*T   + a4*T^2   + a5*T^3  + a6*T^4 */
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
         const CoeffType * const a =
           this->_species_curve_fits[species]->coefficients(i);
         returnval = Antioch::if_else
           (interval == i,
            StateType(a[0]/cache.T2 + a[1]/cache.T + a[2] + a[3]*cache.T +
                      a[4]*cache.T2 + a[5]*cache.T3 + a[6]*cache.T4),
            returnval);
       }
 
     return returnval;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::cv	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

Definition at line 553 of file cea_thermo.h.

References cp().

   {
     return this->cp(cache,species) - _chem_mixture.R(species);
   }

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, StateType >::type Antioch::CEAThermodynamics< CoeffType >::cv	(	const Cache< StateType > &	cache,
		const VectorStateType &	mass_fractions
	)		const

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, StateType >::type Antioch::CEAThermodynamics< CoeffType >::cv	(	const Cache< StateType > &	cache,
		const VectorStateType &	mass_fractions
	)		const

inline

Definition at line 564 of file cea_thermo.h.

References cp().

   {
     return this->cp(cache,mass_fractions) - _chem_mixture.R(mass_fractions);
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::dh_RT_minus_s_R_dT	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

We currently need different specializations for scalar vs vector inputs here.

Definition at line 487 of file cea_thermo.h.

References antioch_assert_less, Antioch::if_else(), Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::lnT, Antioch::max(), Antioch::min(), Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T2, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T3, and Antioch::zero_clone().

Referenced by tester(), and vectester().

   {
     antioch_assert_less( species, _species_curve_fits.size() );
     // FIXME - we need assert_less to be vectorizable
     // antioch_assert_less( _species_curve_fits[species]->interval(cache.T),
     //                      _species_curve_fits[species]->n_intervals() );
 
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->_species_curve_fits[species]->interval(cache.T);
 
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     // FIXME - this needs expression templates to be faster...
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     typedef typename
       Antioch::raw_value_type<StateType>::type raw_type;
 
     /* h/RT = -a[0]/T2    + a[1]*lnT/T + a[2]     + a[3]*T/2. + a[4]*T2/3. + a[5]*T3/4. + a[6]*T4/5. + a[7]/T,
        s/R  = -a[0]/T2/2. - a[1]/T     + a[2]*lnT + a[3]*T    + a[4]*T2/2. + a[5]*T3/3. + a[6]*T4/4. + a[8]   */
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
         const CoeffType * const a =
           this->_species_curve_fits[species]->coefficients(i);
         returnval = Antioch::if_else
           (interval == i,
            StateType(a[0]/cache.T3 - a[7]/cache.T2 -
                      a[1]*cache.lnT/cache.T2 - a[2]/cache.T -
                      a[3]/raw_type(2) - a[4]*cache.T/raw_type(3) -
                      a[5]*cache.T2/raw_type(4) -
                      a[6]*cache.T3/raw_type(5)),
            returnval);
       }
 
     return returnval;
   }

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::dh_RT_minus_s_R_dT	(	const Cache< StateType > &	cache,
		VectorStateType &	dh_RT_minus_s_R_dT
	)		const

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::dh_RT_minus_s_R_dT	(	const Cache< StateType > &	cache,
		VectorStateType &	dh_RT_minus_s_R_dT
	)		const

inline

Definition at line 534 of file cea_thermo.h.

References antioch_assert_equal_to.

   {
     antioch_assert_equal_to( dh_RT_minus_s_R_dT.size(), _species_curve_fits.size() );
 
     for( unsigned int s = 0; s < _species_curve_fits.size(); s++ )
       {
         dh_RT_minus_s_R_dT[s] = this->dh_RT_minus_s_R_dT(cache,s);
       }
 
     return;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::h	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

Definition at line 306 of file cea_thermo.h.

References Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T.

   {
     return this->_chem_mixture.R(species)*cache.T*this->h_over_RT(cache,species);
   }

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::h	(	const Cache< StateType > &	cache,
		VectorStateType &	h
	)		const

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::h	(	const Cache< StateType > &	cache,
		VectorStateType &	h
	)		const

inline

Definition at line 318 of file cea_thermo.h.

References antioch_assert_equal_to, and Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T.

   {
     antioch_assert_equal_to( h.size(), _species_curve_fits.size() );
 
     for( unsigned int s = 0; s < _species_curve_fits.size(); s++ )
       {
         h[s] = this->_chem_mixture.R(s)*cache.T*this->h_over_RT(cache,s);
       }
 
     return;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::h_over_RT	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

Definition at line 372 of file cea_thermo.h.

References antioch_assert_less, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::lnT, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T2, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T3, and Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T4.

   {
     antioch_assert_less( species, _species_curve_fits.size() );
     antioch_assert_less( _species_curve_fits[species]->interval(cache.T),
                          _species_curve_fits[species]->n_intervals() );
 
     const unsigned int interval = this->_species_curve_fits[species]->interval(cache.T);
 
     const CoeffType *a = this->_species_curve_fits[species]->coefficients(interval);
 
     typedef typename
       Antioch::raw_value_type<StateType>::type raw_type;
 
     /* h/RT = -a0*T^-2   + a1*T^-1*lnT + a2     + a3*T/2 + a4*T^2/3 + a5*T^3/4 + a6*T^4/5 + a7/T */
     return -a[0]/cache.T2 + a[1]*cache.lnT/cache.T + a[2] +
            a[3]*cache.T/raw_type(2) + a[4]*cache.T2/raw_type(3) +
            a[5]*cache.T3/raw_type(4) + a[6]*cache.T4/raw_type(5) +
            a[7]/cache.T;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::h_RT_minus_s_R	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

We currently need different specializations for scalar vs vector inputs here.

Definition at line 420 of file cea_thermo.h.

References antioch_assert_less, Antioch::if_else(), Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::lnT, Antioch::max(), Antioch::min(), Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T2, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T3, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T4, and Antioch::zero_clone().

Referenced by tester(), tester_N2N(), and vectester().

   {
     antioch_assert_less( species, _species_curve_fits.size() );
     // FIXME - we need assert_less to be vectorizable
 //    antioch_assert_less( _species_curve_fits[species]->interval(cache.T),
 //                       _species_curve_fits[species]->n_intervals() );
 
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->_species_curve_fits[species]->interval(cache.T);
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     // FIXME - this needs expression templates to be faster...
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     typedef typename
       Antioch::raw_value_type<StateType>::type raw_type;
 
     /* h/RT = -a[0]/T2    + a[1]*lnT/T + a[2]     + a[3]*T/2. + a[4]*T2/3. + a[5]*T3/4. + a[6]*T4/5. + a[7]/T,
        s/R  = -a[0]/T2/2. - a[1]/T     + a[2]*lnT + a[3]*T    + a[4]*T2/2. + a[5]*T3/3. + a[6]*T4/4. + a[8]   */
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
         const CoeffType * const a =
           this->_species_curve_fits[species]->coefficients(i);
         returnval = Antioch::if_else
           (interval == i,
            StateType(-a[0]/cache.T2/raw_type(2) +
                      (a[1] + a[7])/cache.T +
                      a[1]*cache.lnT/cache.T - a[2]*cache.lnT +
                      (a[2] - a[8]) - a[3]*cache.T/raw_type(2) -
                      a[4]*cache.T2/raw_type(6) -
                      a[5]*cache.T3/raw_type(12) -
                      a[6]*cache.T4/raw_type(20)),
            returnval);
       }
 
     return returnval;
   }

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::h_RT_minus_s_R	(	const Cache< StateType > &	cache,
		VectorStateType &	h_RT_minus_s_R
	)		const

template<typename CoeffType = double>

template<typename StateType , typename VectorStateType >

enable_if_c< has_size<VectorStateType>::value, void >::type Antioch::CEAThermodynamics< CoeffType >::h_RT_minus_s_R	(	const Cache< StateType > &	cache,
		VectorStateType &	h_RT_minus_s_R
	)		const

inline

Definition at line 468 of file cea_thermo.h.

References antioch_assert_equal_to.

   {
     antioch_assert_equal_to( h_RT_minus_s_R.size(), _species_curve_fits.size() );
 
     for( unsigned int s = 0; s < _species_curve_fits.size(); s++ )
       {
         h_RT_minus_s_R[s] = this->h_RT_minus_s_R(cache,s);
       }
 
     return;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::CEAThermodynamics< CoeffType >::s_over_R	(	const Cache< StateType > &	cache,
		unsigned int	species
	)		const

inline

Definition at line 396 of file cea_thermo.h.

References antioch_assert_less, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::lnT, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T2, Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T3, and Antioch::CEAThermodynamics< CoeffType >::Cache< StateType >::T4.

   {
     antioch_assert_less( species, _species_curve_fits.size() );
     antioch_assert_less( _species_curve_fits[species]->interval(cache.T),
                          _species_curve_fits[species]->n_intervals() );
 
     const unsigned int interval = this->_species_curve_fits[species]->interval(cache.T);
 
     const CoeffType *a = this->_species_curve_fits[species]->coefficients(interval);
 
     typedef typename
       Antioch::raw_value_type<StateType>::type raw_type;
 
     /* s/R = -a0*T^-2/2 - a1*T^-1     + a2*lnT + a3*T   + a4*T^2/2 + a5*T^3/3 + a6*T^4/4 + a8 */
     return -a[0]/cache.T2/raw_type(2) - a[1]/cache.T +
            a[2]*cache.lnT + a[3]*cache.T + a[4]*cache.T2/raw_type(2) +
            a[5]*cache.T3/raw_type(3) + a[6]*cache.T4/raw_type(4) + a[8];
   }

Member Data Documentation

template<typename CoeffType = double>

const ChemicalMixture<CoeffType>& Antioch::CEAThermodynamics< CoeffType >::_chem_mixture

protected

Definition at line 168 of file cea_thermo.h.

template<typename CoeffType = double>

std::vector<CoeffType> Antioch::CEAThermodynamics< CoeffType >::_cp_at_200p1

protected

Definition at line 172 of file cea_thermo.h.

Referenced by Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics().

template<typename CoeffType = double>

std::vector<CEACurveFit<CoeffType>* > Antioch::CEAThermodynamics< CoeffType >::_species_curve_fits

protected

Definition at line 170 of file cea_thermo.h.

Referenced by Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics().

The documentation for this class was generated from the following files:

src/parsing/include/antioch/ascii_parser.h
src/thermo/include/antioch/cea_thermo.h

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Detailed Description

template<typename CoeffType = double> class Antioch::CEAThermodynamics< CoeffType >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename CoeffType = double>
class Antioch::CEAThermodynamics< CoeffType >