This class stores the NASA polynomial fit to the thermodynamics quantities $\frac{C_p}{\mathrm{R}}$ $\frac{h}{\mathrm{R}T}$ and $\frac{s}{\mathrm{R}T}$ . More...

#include <ascii_parser.h>

Inheritance diagram for Antioch::NASA9CurveFit< CoeffType >:

Public Member Functions
	NASA9CurveFit (const std::vector< CoeffType > &coeffs, const std::vector< CoeffType > &temps)
	Accepts a vector temperatures to specify the temp. intervals. More...

	NASA9CurveFit (const std::vector< CoeffType > &coeffs)
	Assumes the coefficients correspond to the default temperature intervals. More...

	~NASA9CurveFit ()

template<typename StateType >
const StateType	cp_over_R (const TempCache< StateType > &cache) const

template<typename StateType >
StateType	h_over_RT (const TempCache< StateType > &cache) const

template<typename StateType >
StateType	s_over_R (const TempCache< StateType > &cache) const

template<typename StateType >
StateType	h_RT_minus_s_R (const TempCache< StateType > &cache) const

template<typename StateType >
StateType	dh_RT_minus_s_R_dT (const TempCache< StateType > &cache) const

unsigned int	n_intervals () const
	The number of intervals for this NASA9 curve fit. More...

template<typename StateType >
Antioch::rebind< StateType, unsigned int >::type	interval (const StateType &T) const
	The interval the input temperature lies in. More...

template<typename StateType >
Antioch::rebind< StateType, unsigned int >::type	interval (const StateType &T) const

const CoeffType *	coefficients (const unsigned int interval) const
	The ordering/packing of the coefficients will depend on the subclass. More...

Protected Member Functions
	NASA9CurveFit ()

void	init_nasa9_temps (const std::vector< CoeffType > &coeffs, unsigned n_coeffs)

void	check_coeff_size () const

void	check_temp_coeff_size_consistency () const

Protected Attributes
unsigned int	_n_coeffs
	The number of coefficients in each interval. More...

std::vector< CoeffType >	_coefficients
	The coefficient data. More...

std::vector< CoeffType >	_temp
	The temperatures. More...

Detailed Description

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

This class stores the NASA polynomial fit to the thermodynamics quantities $\frac{C_p}{\mathrm{R}}$ $\frac{h}{\mathrm{R}T}$ and $\frac{s}{\mathrm{R}T}$ .

This formulation requires nine coefficients, from $a_0$ to $a_8$ .

The default temperature intervals are [200–1,000], [1,000–6,000], [6,000–20,000] K.

The equations are:

$\frac{Cp}{\mathrm{R}} = \frac{a_0}{T^2} + \frac{a_1}{T} + a_2 + a_3 T + a_4 T^2 + a_5 T^3 + a_6 T^4$

$\frac{h}{\mathrm{R}T} = -\frac{a_0}{T^2} + \frac{a_1}{T} \ln(T) + a2 + \frac{a_3}{2} T + \frac{a_4}{3} T^2 + \frac{a_5}{4} T^3 + \frac{a_6}{5} T^4 + \frac{a_7}{T}$

$\frac{s}{\mathrm{R}} = -\frac{a_0}{2T^2} - \frac{a_1}{T} + a_2 \ln(T) + a_3 T + \frac{a_4}{2} T^2 + \frac{a_5}{3} T^3 + \frac{a_6}{4} T^4 + a_8$

Definition at line 68 of file ascii_parser.h.

Constructor & Destructor Documentation

template<typename CoeffType >

Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit	(	const std::vector< CoeffType > &	coeffs,
		const std::vector< CoeffType > &	temps
	)

inline

Accepts a vector temperatures to specify the temp. intervals.

Definition at line 157 of file nasa9_curve_fit.h.

References Antioch::NASACurveFitBase< CoeffType >::_n_coeffs, Antioch::NASACurveFitBase< CoeffType >::check_coeff_size(), and Antioch::NASACurveFitBase< CoeffType >::check_temp_coeff_size_consistency().

     : NASACurveFitBase<CoeffType>(coeffs,temp)
   {
     this->_n_coeffs = 9;
 
     this->check_coeff_size();
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType >

Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit ( const std::vector< CoeffType > & coeffs )

inline

Assumes the coefficients correspond to the default temperature intervals.

If there are not enough coefficients for the third interval, then this only builds up through the second interval.

Definition at line 169 of file nasa9_curve_fit.h.

References Antioch::NASACurveFitBase< CoeffType >::_n_coeffs, Antioch::NASACurveFitBase< CoeffType >::check_coeff_size(), Antioch::NASACurveFitBase< CoeffType >::check_temp_coeff_size_consistency(), and Antioch::NASA9CurveFit< CoeffType >::init_nasa9_temps().

     : NASACurveFitBase<CoeffType>(coeffs,std::vector<CoeffType>())
   {
     this->_n_coeffs = 9;
     this->check_coeff_size();
 
     this->init_nasa9_temps( coeffs, this->_n_coeffs );
 
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType = double>

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

inline

Definition at line 82 of file nasa9_curve_fit.h.

82 {};

template<typename CoeffType = double>

Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit ( )

inlineprotected

Definition at line 146 of file nasa9_curve_fit.h.

146 {};

Member Function Documentation

template<typename CoeffType >

void Antioch::NASACurveFitBase< CoeffType >::check_coeff_size ( ) const

inlineprotectedinherited

Definition at line 143 of file nasa_curve_fit_base.h.

References antioch_error_msg.

Referenced by Antioch::CEACurveFit< CoeffType >::CEACurveFit(), Antioch::NASA7CurveFit< CoeffType >::NASA7CurveFit(), and Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit().

   {
     if( this->_coefficients.size()%this->_n_coeffs != 0 )
       {
         std::stringstream ncs;
         ncs << this->_n_coeffs;
 
         std::stringstream css;
         css << this->_coefficients.size()%this->_n_coeffs;
 
         std::string msg = "ERROR: coeffs size must be a multiple of "+ncs.str()+"\n";
         msg += "       Found "+css.str()+"\n";
         antioch_error_msg(msg);
       }
   }

template<typename CoeffType >

void Antioch::NASACurveFitBase< CoeffType >::check_temp_coeff_size_consistency ( ) const

inlineprotectedinherited

Definition at line 161 of file nasa_curve_fit_base.h.

References antioch_error_msg.

Referenced by Antioch::CEACurveFit< CoeffType >::CEACurveFit(), Antioch::NASA7CurveFit< CoeffType >::NASA7CurveFit(), and Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit().

   {
     if( this->_temp.size() != this->_coefficients.size()/this->_n_coeffs + 1 )
       {
         std::stringstream tss;
         tss << this->_temp.size();
 
         std::stringstream css;
         css << this->_coefficients.size();
 
         std::stringstream cssd;
         cssd << this->_n_coeffs*(this->_temp.size()-1);
 
         std::string msg = "ERROR: Inconsistency in temp and coeff size.\n";
         msg += "       Found temp size of "+tss.str()+"\n";
         msg += "       Found coeff size of "+css.str()+"\n";
         msg += "       Expected coeff size of "+cssd.str()+"\n";
         antioch_error_msg(msg);
       }
   }

template<typename CoeffType >

const CoeffType * Antioch::NASACurveFitBase< CoeffType >::coefficients ( const unsigned int interval ) const

inlineinherited

The ordering/packing of the coefficients will depend on the subclass.

Returns: a pointer to the coefficients in the interval specified.

Definition at line 133 of file nasa_curve_fit_base.h.

References antioch_assert_less, and antioch_assert_less_equal.

Referenced by AntiochTesting::NASA7XMLParsingTest< long double >::check_curve_fits(), and AntiochTesting::NASA9XMLParsingTest< long double >::test_supplied_species().

   {
     antioch_assert_less( interval, this->n_intervals() );
     antioch_assert_less_equal( _n_coeffs*(interval+1), _coefficients.size() );
 
     return &_coefficients[_n_coeffs*interval];
   }

template<typename CoeffType >

template<typename StateType >

const StateType Antioch::NASA9CurveFit< CoeffType >::cp_over_R ( const TempCache< StateType > & cache ) const

inline

Returns: the value $\frac{Cp}{\mathrm{R}}$
$\frac{Cp}{\mathrm{R}} = \frac{a_0}{T^2} + \frac{a_1}{T} + a_2 + a_3 T + a_4 T^2 + a_5 T^3 + a_6 T^4$

Definition at line 199 of file nasa9_curve_fit.h.

References Antioch::if_else(), Antioch::max(), Antioch::min(), Antioch::TempCache< StateType >::T, Antioch::TempCache< StateType >::T2, Antioch::TempCache< StateType >::T3, Antioch::TempCache< StateType >::T4, and Antioch::zero_clone().

Referenced by AntiochTesting::NASA9CurveFitTest< long double >::test_cp().

   {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->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);
 
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
         const CoeffType * const a =
           this->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::NASA9CurveFit< CoeffType >::dh_RT_minus_s_R_dT ( const TempCache< StateType > & cache ) const

inline

Returns: the value $\frac{\partial\left(\frac{g}{\mathrm{R}T}\right)}{\partial T} = \frac{\partial\left(\frac{h}{\mathrm{R}T} - \frac{s}{R}\right)}{\partial T}$
$\frac{g}{\mathrm{R}T} = \frac{a_0}{T^3} + \frac{a_1 + a_8}{T^2} + a_1 \ln(T) + a_1 - \frac{a2}{T} - \frac{a_3}{2} - \frac{a_4}{3} T - \frac{a_5}{4} T^2 - \frac{a_6}{5} T^3$

Definition at line 317 of file nasa9_curve_fit.h.

References Antioch::if_else(), Antioch::TempCache< StateType >::lnT, Antioch::max(), Antioch::min(), Antioch::TempCache< StateType >::T, Antioch::TempCache< StateType >::T2, Antioch::TempCache< StateType >::T3, and Antioch::zero_clone().

    {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->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);
 
     /* 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->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]/2.  - a[4]*cache.T/3. - a[5]*cache.T2/4. -
                      a[6]*cache.T3/5.),
            returnval);
       }
 
     return returnval;
 
    }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::NASA9CurveFit< CoeffType >::h_over_RT ( const TempCache< StateType > & cache ) const

inline

Returns: the value $\frac{h}{\mathrm{R}T}$
$\frac{h}{\mathrm{R}T} = -\frac{a_0}{T^2} + \frac{a_1}{T} \ln(T) + a2 + \frac{a_3}{2} T + \frac{a_4}{3} T^2 + \frac{a_5}{4} T^3 + \frac{a_6}{5} T^4 + \frac{a_8}{T}$

Definition at line 229 of file nasa9_curve_fit.h.

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

Referenced by AntiochTesting::NASA9CurveFitTest< long double >::test_h().

   {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->interval(cache.T);
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
          const CoeffType *a = this->coefficients(interval);
 
          /* 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 */
         returnval = Antioch::if_else
         ( interval == i,
            StateType( -a[0]/cache.T2 + a[1]*cache.lnT/cache.T + a[2] +
                        a[3]*cache.T/2.0L + a[4]*cache.T2/3.0L + a[5]*cache.T3/4.0L +
                        a[6]*cache.T4/5.0L + a[7]/cache.T),
            returnval);
        }
        return returnval;
    }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::NASA9CurveFit< CoeffType >::h_RT_minus_s_R ( const TempCache< StateType > & cache ) const

inline

Returns: the value $\frac{g}{\mathrm{R}T} = \frac{h}{\mathrm{R}T} - \frac{s}{R}$
$\frac{g}{\mathrm{R}T} = -\frac{a_0}{2T^2} - \frac{a_1 + a_8}{T} + \frac{a_1}{T} \ln(T) - a2 \ln(T) + (a_2 - a_9) - \frac{a_3}{2} T - \frac{a_4}{6} T^2 - \frac{a_5}{12} T^3 - \frac{a_6}{20} T^4$

Definition at line 286 of file nasa9_curve_fit.h.

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

   {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->interval(cache.T);
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
          const CoeffType *a = this->coefficients(interval);
 
     /* 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]   */
         returnval = Antioch::if_else
         ( interval == i,
            StateType(-a[0]/cache.T2/2.0 + (a[1] + a[7])/cache.T +
                      a[1]*cache.lnT/cache.T - a[2]*cache.lnT +
                      (a[2] - a[8]) - a[3]*cache.T/2.0 -
                      a[4]*cache.T2/6.0 - a[5]*cache.T3/12.0 -
                      a[6]*cache.T4/20.0),
            returnval);
        }
        return returnval;
    }

template<typename CoeffType >

void Antioch::NASA9CurveFit< CoeffType >::init_nasa9_temps	(	const std::vector< CoeffType > &	coeffs,
		unsigned	n_coeffs
	)

inlineprotected

Definition at line 182 of file nasa9_curve_fit.h.

Referenced by Antioch::CEACurveFit< CoeffType >::CEACurveFit(), and Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit().

   {
     // All default NASA9 curve fits should have this
     this->_temp.resize(3);
     this->_temp[0] = 200.L;
     this->_temp[1] = 1000.L;
     this->_temp[2] = 6000.L;
 
     // But some also have this last interval. We infer this from the size of the coeffs.
     if( coeffs.size()/n_coeffs == 3 )
       this->_temp.push_back(20000.L);
   }

template<typename CoeffType = double>

template<typename StateType >

Antioch::rebind<StateType, unsigned int>::type Antioch::NASACurveFitBase< CoeffType >::interval ( const StateType & T ) const

inherited

The interval the input temperature lies in.

Returns: which curve fit interval the input temperature lies in.

template<typename CoeffType = double>

template<typename StateType >

Antioch::rebind<StateType, unsigned int>::type Antioch::NASACurveFitBase< CoeffType >::interval ( const StateType & T ) const

inlineinherited

Definition at line 113 of file nasa_curve_fit_base.h.

References Antioch::constant_clone(), Antioch::if_else(), and Antioch::zero_clone().

   {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     UIntType interval;
     Antioch::zero_clone(interval, T);
 
     for(unsigned int i = 1; i < _temp.size(); ++i)
     {
         interval = Antioch::if_else
           (T > _temp[i-1] && T < _temp[i],
            Antioch::constant_clone(interval, i-1),
            interval );
     }
 
     return interval;
   }

template<typename CoeffType >

unsigned int Antioch::NASACurveFitBase< CoeffType >::n_intervals ( ) const

inlineinherited

The number of intervals for this NASA9 curve fit.

Definition at line 106 of file nasa_curve_fit_base.h.

Referenced by AntiochTesting::NASA7XMLParsingTest< long double >::check_curve_fits(), and AntiochTesting::NASA9XMLParsingTest< long double >::test_supplied_species().

107 { return _coefficients.size() / _n_coeffs; }

Antioch::NASACurveFitBase::_n_coeffs

unsigned int _n_coeffs

The number of coefficients in each interval.

Definition: nasa_curve_fit_base.h:77

Antioch::NASACurveFitBase::_coefficients

std::vector< CoeffType > _coefficients

The coefficient data.

Definition: nasa_curve_fit_base.h:85

template<typename CoeffType >

template<typename StateType >

StateType Antioch::NASA9CurveFit< CoeffType >::s_over_R ( const TempCache< StateType > & cache ) const

inline

Returns: the value $\frac{s}{\mathrm{R}}$
$\frac{s}{\mathrm{R}} = -\frac{a_0}{2T^2} - \frac{a_1}{T} + a_2 \ln(T) + a_3 T + \frac{a_4}{2} T^2 + \frac{a_5}{3} T^3 + \frac{a_6}{4} T^4 + a_9$

Definition at line 257 of file nasa9_curve_fit.h.

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

Referenced by AntiochTesting::NASA9CurveFitTest< long double >::test_s().

   {
     typedef typename
       Antioch::rebind<StateType, unsigned int>::type UIntType;
     const UIntType interval = this->interval(cache.T);
     const unsigned int begin_interval = Antioch::min(interval);
     const unsigned int end_interval = Antioch::max(interval)+1;
 
     StateType returnval = Antioch::zero_clone(cache.T);
 
     for (unsigned int i=begin_interval; i != end_interval; ++i)
       {
          const CoeffType *a = this->coefficients(interval);
 
     /* 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 */
         returnval = Antioch::if_else
         ( interval == i,
            StateType( -a[0]/cache.T2/2.0 - a[1]/cache.T + a[2]*cache.lnT
                       + a[3]*cache.T + a[4]*cache.T2/2.0 + a[5]*cache.T3/3.0
                       + a[6]*cache.T4/4.0 + a[8]),
            returnval);
        }
        return returnval;
    }

Member Data Documentation

template<typename CoeffType = double>

std::vector<CoeffType> Antioch::NASACurveFitBase< CoeffType >::_coefficients

protectedinherited

The coefficient data.

The coeffcients are packed in linear ordering. That is, a0-a9 for the first interval, a0-a9 for the second interval, and so on.

Definition at line 85 of file nasa_curve_fit_base.h.

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

template<typename CoeffType = double>

unsigned int Antioch::NASACurveFitBase< CoeffType >::_n_coeffs

protectedinherited

The number of coefficients in each interval.

Definition at line 77 of file nasa_curve_fit_base.h.

Referenced by Antioch::CEACurveFit< CoeffType >::CEACurveFit(), Antioch::NASA7CurveFit< CoeffType >::NASA7CurveFit(), and Antioch::NASA9CurveFit< CoeffType >::NASA9CurveFit().

template<typename CoeffType = double>

std::vector<CoeffType> Antioch::NASACurveFitBase< CoeffType >::_temp

protectedinherited

The temperatures.

The temperature defining the intervals

Definition at line 91 of file nasa_curve_fit_base.h.

Referenced by Antioch::CEACurveFit< CoeffType >::CEACurveFit(), and Antioch::NASA7CurveFit< CoeffType >::NASA7CurveFit().

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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