This class only differs from NASA9CurveFit in the construction. More...

#include <ascii_parser.h>

Inheritance diagram for Antioch::CEACurveFit< CoeffType >:

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

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

	~CEACurveFit ()

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	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...

Private Member Functions
void	remap_coeffs (const std::vector< CoeffType > &coeffs)

Detailed Description

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

This class only differs from NASA9CurveFit in the construction.

Here, we assume that there are 10 coefficients, with the 7th being zero. This is exactly the format output from NASA's CEA program and, hence, this class was build to enable this compatiblity. Internally, the coefficients are remapped to 9 coefficients and is then functionally identical to NASA9CurveFit.

Definition at line 72 of file ascii_parser.h.

Constructor & Destructor Documentation

template<typename CoeffType >

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

inline

Definition at line 61 of file cea_curve_fit.h.

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

     :NASA9CurveFit<CoeffType>()
   {
 
     if( this->_coefficients.size()%10 != 0 )
       antioch_error_msg("ERROR: Expected CEA style of input for coefficients! Must be a multiple of 10!");
 
     this->_n_coeffs = 9;
 
     // If no temp is provided, we assume the standard CEA form.
     this->init_nasa9_temps( coeffs, 10 );
 
     this->remap_coeffs(coeffs);
 
     this->check_coeff_size();
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType >

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

inline

Definition at line 81 of file cea_curve_fit.h.

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

     :NASA9CurveFit<CoeffType>()
   {
     if( this->_coefficients.size()%10 != 0 )
       antioch_error_msg("ERROR: Expected CEA style of input for coefficients! Must be a multiple of 10!");
 
     this->_n_coeffs = 9;
 
     this->_temp = temp;
 
     this->remap_coeffs(coeffs);
 
     this->check_coeff_size();
     this->check_temp_coeff_size_consistency();
   }

template<typename CoeffType = double>

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

inline

Definition at line 51 of file cea_curve_fit.h.

51 {}

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

inlineinherited

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

inlineinherited

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

inlineinherited

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

inlineinherited

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
	)

inlineprotectedinherited

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 >

void Antioch::CEACurveFit< CoeffType >::remap_coeffs ( const std::vector< CoeffType > & coeffs )

inlineprivate

Definition at line 100 of file cea_curve_fit.h.

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

   {
     this->_coefficients.resize(this->_n_coeffs*(this->_temp.size()-1),0.0);
 
     for( unsigned int t = 0; t < this->_temp.size()-1; t++ )
       {
         for( unsigned int c = 0; c < 7; c++ )
           {
             unsigned int i = 10*t + c;
             unsigned int j = 9*t + c;
             this->_coefficients[j] = coeffs[i];
           }
 
         for( unsigned int c = 7; c < 9; c++ )
           {
             unsigned int i = 10*t + c;
             unsigned int j = 9*t + c;
             this->_coefficients[j] = coeffs[i+1];
           }
       }
   }

template<typename CoeffType >

template<typename StateType >

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

inlineinherited

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/cea_curve_fit.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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