#include <ascii_parser.h>

Inheritance diagram for Antioch::NASA7CurveFit< CoeffType >:

Public Member Functions
	NASA7CurveFit (const std::vector< CoeffType > &coeffs)

	NASA7CurveFit (const std::vector< CoeffType > &coeffs, const std::vector< CoeffType > &temp)

	~NASA7CurveFit ()

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
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::NASA7CurveFit< CoeffType >

Definition at line 65 of file ascii_parser.h.

Constructor & Destructor Documentation

template<typename CoeffType >

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

inline

Definition at line 122 of file nasa7_curve_fit.h.

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

     : NASACurveFitBase<CoeffType>(coeffs,std::vector<CoeffType>())
   {
     this->_n_coeffs = 7;
 
     this->_temp.resize(3);
     this->_temp[0] = 300.L;
     this->_temp[1] = 1000.L;
     this->_temp[2] = 5000.L;
 
     this->check_coeff_size();
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType >

Antioch::NASA7CurveFit< CoeffType >::NASA7CurveFit	(	const std::vector< CoeffType > &	coeffs,
		const std::vector< CoeffType > &	temp
	)

inline

Definition at line 111 of file nasa7_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 = 7;
 
     this->check_coeff_size();
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType = double>

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

inline

Definition at line 46 of file nasa7_curve_fit.h.

46 {};

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::NASA7CurveFit< 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 139 of file nasa7_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::NASA7CurveFitTest< 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] + a[1]*cache.T + a[2]*cache.T2 + a[3]*cache.T3 + a[4]*cache.T4),
            returnval);
       }
 
     return returnval;
   }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::NASA7CurveFit< 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_5}{T^2} - \frac{a_0}{T} - \frac{a_1}{2} - \frac{a_2}{3} T - \frac{a_3}{4} T^2 - \frac{a_4}{5} T^3$

Definition at line 253 of file nasa7_curve_fit.h.

References Antioch::if_else(), 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[8]/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[9]   */
     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[5]/cache.T2     - a[0]/cache.T
                      - a[1]/2.L          - a[2]*cache.T/3.L
                      - a[3]*cache.T2/4.L - a[4]*cache.T3/5.L),
            returnval);
       }
 
     return returnval;
 
    }

template<typename CoeffType >

template<typename StateType >

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

inline

Returns: the value $\frac{h}{\mathrm{R}T}$
$\frac{h}{\mathrm{R}T} = a0 + \frac{a_1}{2} T + \frac{a_2}{3} T^2 + \frac{a_3}{4} T^3 + \frac{a_4}{5} T^4 + \frac{a_5}{T}$

Definition at line 166 of file nasa7_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::NASA7CurveFitTest< 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     + a1*T/2 + a2*T^2/3 + a3*T^3/4 + a4*T^4/5 + a5/T */
         returnval = Antioch::if_else
         ( interval == i,
            StateType(  a[0] +
                        a[1]*cache.T/2.0L + a[2]*cache.T2/3.0L + a[3]*cache.T3/4.0L +
                        a[4]*cache.T4/5.0L + a[5]/cache.T),
            returnval);
        }
        return returnval;
    }

template<typename CoeffType >

template<typename StateType >

StateType Antioch::NASA7CurveFit< 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_5}{T} - a0 \ln(T) + (a_0 - a_6) - \frac{a_1}{2} T - \frac{a_2}{6} T^2 - \frac{a_3}{12} T^3 - \frac{a_4}{20} T^4$

Definition at line 223 of file nasa7_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]     + a[1]*T/2. + a[2]*T2/3. + a[3]*T3/4. + a[4]*T4/5. + a[5]/T,
        s/R  =  a[0]*lnT + a[1]*T    + a[2]*T2/2. + a[3]*T3/3. + a[4]*T4/4. + a[6]   */
         returnval = Antioch::if_else
         ( interval == i,
            StateType(a[5]/cache.T - a[0]*cache.lnT
                      + a[0] - a[6]
                      - a[1]/2.L*cache.T   - a[2]*cache.T2/6.L
                      - a[3]*cache.T3/12.L - a[4]*cache.T4/20.L),
            returnval);
        }
        return returnval;
    }

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::NASA7CurveFit< CoeffType >::s_over_R ( const TempCache< StateType > & cache ) const

inline

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

Definition at line 194 of file nasa7_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::NASA7CurveFitTest< 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*lnT + a1*T   + a2*T^2/2 + a3*T^3/3 + a4*T^4/4 + a6 */
         returnval = Antioch::if_else
         ( interval == i,
            StateType(   a[0]*cache.lnT
                       + a[1]*cache.T + a[2]*cache.T2/2.0L + a[3]*cache.T3/3.0L
                       + a[4]*cache.T4/4.0L + a[6]),
            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/nasa7_curve_fit.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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