Class to handle computing mass source terms for a given ReactionSet. More...

#include <kinetics_evaluator.h>

Public Member Functions
	KineticsEvaluator (const ReactionSet< CoeffType > &reaction_set, const StateType &example)
	Constructor. Requires a reaction set to be evaluated later,. More...

	~KineticsEvaluator ()

const ReactionSet< CoeffType > &	reaction_set () const

template<typename VectorStateType , typename KC >
void	compute_mass_sources (const KC &conditions, const VectorStateType &molar_densities, const VectorStateType &h_RT_minus_s_R, VectorStateType &mass_sources)
	Compute species production/destruction rates per unit volume. More...

template<typename VectorStateType , typename KC >
void	compute_mass_sources_and_derivs (const KC &conditions, const VectorStateType &molar_densities, const VectorStateType &h_RT_minus_s_R, const VectorStateType &dh_RT_minus_s_R_dT, VectorStateType &mass_sources, VectorStateType &dmass_dT, std::vector< VectorStateType > &dmass_drho_s)
	Compute species production/destruction rate derivatives. More...

template<typename VectorStateType , typename KC >
void	compute_mole_sources (const KC &conditions, const VectorStateType &molar_densities, const VectorStateType &h_RT_minus_s_R, VectorStateType &mole_sources)
	Compute species molar production/destruction rates per unit volume. More...

template<typename VectorStateType , typename KC >
void	compute_mole_sources_and_derivs (const KC &conditions, const VectorStateType &molar_densities, const VectorStateType &h_RT_minus_s_R, const VectorStateType &dh_RT_minus_s_R_dT, VectorStateType &mole_sources, VectorStateType &dmole_dT, std::vector< VectorStateType > &dmole_dX_s)
	Compute species production/destruction rate derivatives. More...

unsigned int	n_species () const

unsigned int	n_reactions () const

Protected Attributes
const ReactionSet< CoeffType > &	_reaction_set

const ChemicalMixture < CoeffType > &	_chem_mixture

std::vector< StateType >	_net_reaction_rates

std::vector< StateType >	_dnet_rate_dT

std::vector< std::vector < StateType > >	_dnet_rate_dX_s

Detailed Description

template<typename CoeffType = double, typename StateType = CoeffType>
class Antioch::KineticsEvaluator< CoeffType, StateType >

Class to handle computing mass source terms for a given ReactionSet.

This class preallocates work arrays and so must be created within a spawned thread, if running in a threaded environment. It takes a reference to an already created ReactionSet, so there's little construction penalty.

Definition at line 53 of file kinetics_evaluator.h.

Constructor & Destructor Documentation

template<typename CoeffType , typename StateType >

Antioch::KineticsEvaluator< CoeffType, StateType >::KineticsEvaluator	(	const ReactionSet< CoeffType > &	reaction_set,
		const StateType &	example
	)

inline

Constructor. Requires a reaction set to be evaluated later,.

Definition at line 152 of file kinetics_evaluator.h.

References Antioch::ReactionSet< CoeffType >::n_species().

     : _reaction_set( reaction_set ),
       _chem_mixture( reaction_set.chemical_mixture() ),
       _net_reaction_rates( reaction_set.n_reactions(), example ),
       _dnet_rate_dT( reaction_set.n_reactions(), example ),
       _dnet_rate_dX_s( reaction_set.n_reactions() )
   {
 
     for( unsigned int r = 0; r < this->n_reactions(); r++ )
       {
         _dnet_rate_dX_s[r].resize( reaction_set.n_species(), example );
       }
 
     return;
   }

template<typename CoeffType , typename StateType >

Antioch::KineticsEvaluator< CoeffType, StateType >::~KineticsEvaluator ( )

inline

Definition at line 172 of file kinetics_evaluator.h.

   {
     return;
   }

Member Function Documentation

template<typename CoeffType , typename StateType >

template<typename VectorStateType , typename KC >

void Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mass_sources	(	const KC &	conditions,
		const VectorStateType &	molar_densities,
		const VectorStateType &	h_RT_minus_s_R,
		VectorStateType &	mass_sources
	)

inline

Compute species production/destruction rates per unit volume.

$\left(kg/sec/m^3\right)$

Definition at line 234 of file kinetics_evaluator.h.

Referenced by tester(), and vectester().

   {
     // Quantities asserted in compute_mole_sources call
     this->compute_mole_sources( conditions, molar_densities, h_RT_minus_s_R, mass_sources );
 
     // finally scale by molar mass
     for (unsigned int s=0; s < this->n_species(); s++)
       {
         mass_sources[s] *= _chem_mixture.M(s);
       }
     
     return;
   }

template<typename CoeffType , typename StateType >

template<typename VectorStateType , typename KC >

void Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mass_sources_and_derivs	(	const KC &	conditions,
		const VectorStateType &	molar_densities,
		const VectorStateType &	h_RT_minus_s_R,
		const VectorStateType &	dh_RT_minus_s_R_dT,
		VectorStateType &	mass_sources,
		VectorStateType &	dmass_dT,
		std::vector< VectorStateType > &	dmass_drho_s
	)

inline

Compute species production/destruction rate derivatives.

In mass units, e.g. $\frac{\partial \dot{\omega}}{dT} [\left(kg/sec/m^3/K\right)]$

Definition at line 358 of file kinetics_evaluator.h.

Referenced by tester(), and vectester().

   {
     // Asserts are in compute_mole_sources
     this->compute_mole_sources_and_derivs( conditions, molar_densities, h_RT_minus_s_R, dh_RT_minus_s_R_dT,
                                            mass_sources, dmass_dT, dmass_drho_s );
     
     // Convert from mole units to mass units
     for (unsigned int s=0; s < this->n_species(); s++)
       {
         mass_sources[s] *= _chem_mixture.M(s);
         dmass_dT[s] *= _chem_mixture.M(s);
 
         for (unsigned int t=0; t < this->n_species(); t++)
           {
             dmass_drho_s[s][t] *= _chem_mixture.M(s)/_chem_mixture.M(t);
           }
 
       }
 
     return;
   }

template<typename CoeffType , typename StateType >

template<typename VectorStateType , typename KC >

void Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources	(	const KC &	conditions,
		const VectorStateType &	molar_densities,
		const VectorStateType &	h_RT_minus_s_R,
		VectorStateType &	mole_sources
	)

inline

Compute species molar production/destruction rates per unit volume.

$\left(mole/sec/m^3\right)$

Todo:: Make these assertions vector-compatible

Todo:: Do we need to really initialize this?

Definition at line 180 of file kinetics_evaluator.h.

References antioch_assert_equal_to, Antioch::Reaction< CoeffType, VectorCoeffType >::n_products(), Antioch::Reaction< CoeffType, VectorCoeffType >::n_reactants(), Antioch::Reaction< CoeffType, VectorCoeffType >::product_id(), Antioch::Reaction< CoeffType, VectorCoeffType >::product_stoichiometric_coefficient(), Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_id(), Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_stoichiometric_coefficient(), and Antioch::set_zero().

   {
     // antioch_assert_greater(T, 0.0);
     antioch_assert_equal_to( molar_densities.size(), this->n_species() );
     antioch_assert_equal_to( h_RT_minus_s_R.size(), this->n_species() );
     antioch_assert_equal_to( mole_sources.size(), this->n_species() );
 
     Antioch::set_zero(_net_reaction_rates);
 
     Antioch::set_zero(mole_sources);
 
     typename constructor_or_reference<const KineticsConditions<StateType,VectorStateType>, const KC>::type  //either (KineticsConditions<> &) or (KineticsConditions<>)
                 kinetics_conditions(conditions);
     // compute the requisite reaction rates
     this->_reaction_set.compute_reaction_rates( kinetics_conditions, molar_densities,
                                                 h_RT_minus_s_R, _net_reaction_rates );
 
     // compute the actual mole sources in kmol/sec/m^3
     for (unsigned int rxn = 0; rxn < this->n_reactions(); rxn++)
       {
         const Reaction<CoeffType>& reaction = this->_reaction_set.reaction(rxn);
         const StateType rate = _net_reaction_rates[rxn];
         
         // reactant contributions
         for (unsigned int r = 0; r < reaction.n_reactants(); r++)
           {
             const unsigned int r_id = reaction.reactant_id(r);
             const unsigned int r_stoich = reaction.reactant_stoichiometric_coefficient(r);
             
             mole_sources[r_id] -= (static_cast<CoeffType>(r_stoich)*rate);
           }
         
         // product contributions
         for (unsigned int p=0; p < reaction.n_products(); p++)
           {
             const unsigned int p_id = reaction.product_id(p);
             const unsigned int p_stoich = reaction.product_stoichiometric_coefficient(p);
             
             mole_sources[p_id] += (static_cast<CoeffType>(p_stoich)*rate);
           }
       }
 
     return;
   }

template<typename CoeffType , typename StateType >

template<typename VectorStateType , typename KC >

void Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs	(	const KC &	conditions,
		const VectorStateType &	molar_densities,
		const VectorStateType &	h_RT_minus_s_R,
		const VectorStateType &	dh_RT_minus_s_R_dT,
		VectorStateType &	mole_sources,
		VectorStateType &	dmole_dT,
		std::vector< VectorStateType > &	dmole_dX_s
	)

inline

Compute species production/destruction rate derivatives.

In mass units, e.g. $\frac{\partial \dot{\omega}}{dT} [\left(mole/sec/m^3/K\right)]$

Todo:: Make these assertions vector-compatible

Todo:: Do we need to really initialize these?

Todo:: Do we need to really initialize this?

Todo:: Are these going to get optimized out? Should we remove them?

Definition at line 254 of file kinetics_evaluator.h.

References antioch_assert_equal_to, Antioch::Reaction< CoeffType, VectorCoeffType >::n_products(), Antioch::Reaction< CoeffType, VectorCoeffType >::n_reactants(), Antioch::Reaction< CoeffType, VectorCoeffType >::product_id(), Antioch::Reaction< CoeffType, VectorCoeffType >::product_stoichiometric_coefficient(), Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_id(), Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_stoichiometric_coefficient(), and Antioch::set_zero().

   {
     // antioch_assert_greater(T, 0.0);
     antioch_assert_equal_to( molar_densities.size(), this->n_species() );
     antioch_assert_equal_to( h_RT_minus_s_R.size(), this->n_species() );
     antioch_assert_equal_to( dh_RT_minus_s_R_dT.size(), this->n_species() );
     antioch_assert_equal_to( mole_sources.size(), this->n_species() );
     antioch_assert_equal_to( dmole_dT.size(), this->n_species() );
     antioch_assert_equal_to( dmole_dX_s.size(), this->n_species() );
 #ifdef NDEBUG
 #else
     for (unsigned int s=0; s < this->n_species(); s++)
       {
         antioch_assert_equal_to( dmole_dX_s[s].size(), this->n_species() );
       }
 #endif
     
     Antioch::set_zero(_net_reaction_rates);
     Antioch::set_zero(_dnet_rate_dT);
 
     Antioch::set_zero(mole_sources);
     Antioch::set_zero(dmole_dT);
     for (unsigned int s=0; s < this->n_species(); s++)
       {
         Antioch::set_zero(dmole_dX_s[s]);
       }
 
     for (unsigned int rxn=0; rxn < this->n_reactions(); rxn++)
       {
         Antioch::set_zero(_dnet_rate_dX_s[rxn]);
       }
 
     typename constructor_or_reference<const KineticsConditions<StateType,VectorStateType>, const KC>::type  //either (KineticsConditions<> &) or (KineticsConditions<>)
                                         kinetics_conditions(conditions);
     // compute the requisite reaction rates
     this->_reaction_set.compute_reaction_rates_and_derivs( kinetics_conditions, molar_densities, 
                                                            h_RT_minus_s_R, dh_RT_minus_s_R_dT,
                                                            _net_reaction_rates,
                                                            _dnet_rate_dT, 
                                                            _dnet_rate_dX_s );
     // compute the actual mole sources in kmol/sec/m^3
     for (unsigned int rxn = 0; rxn < this->n_reactions(); rxn++)
       {
 
         const Reaction<CoeffType>& reaction = this->_reaction_set.reaction(rxn);
 
         const StateType rate = _net_reaction_rates[rxn];
         const StateType drate_dT = _dnet_rate_dT[rxn];
         const VectorStateType drate_dX_s = _dnet_rate_dX_s[rxn];
 
         // reactant contributions
         for (unsigned int r = 0; r < reaction.n_reactants(); r++)
           {
             const unsigned int r_id = reaction.reactant_id(r);
             const unsigned int r_stoich = reaction.reactant_stoichiometric_coefficient(r);
             
             mole_sources[r_id] -= (static_cast<CoeffType>(r_stoich)*rate);
 
             // d/dT rate contributions
             dmole_dT[r_id] -= (static_cast<CoeffType>(r_stoich)*drate_dT);
 
             // d(.m)/dX_s rate contributions
             for (unsigned int s=0; s < this->n_species(); s++)
               {
                 dmole_dX_s[r_id][s] -= (static_cast<CoeffType>(r_stoich)*drate_dX_s[s]);
               }
           }
         
         // product contributions
         for (unsigned int p=0; p < reaction.n_products(); p++)
           {
             const unsigned int p_id = reaction.product_id(p);
             const unsigned int p_stoich = reaction.product_stoichiometric_coefficient(p);
             
             mole_sources[p_id] += (static_cast<CoeffType>(p_stoich)*rate);
 
             // d/dT rate contributions
             dmole_dT[p_id] += (static_cast<CoeffType>(p_stoich)*drate_dT);
 
             // d/dX_s rate contributions
             for (unsigned int s=0; s < this->n_species(); s++)
               {
                 dmole_dX_s[p_id][s] += (static_cast<CoeffType>(p_stoich)*drate_dX_s[s]);
               }
           }
       }
 
     return;
   }

template<typename CoeffType , typename StateType >

unsigned int Antioch::KineticsEvaluator< CoeffType, StateType >::n_reactions ( ) const

inline

Definition at line 143 of file kinetics_evaluator.h.

   {
     return _reaction_set.n_reactions();
   }

template<typename CoeffType , typename StateType >

unsigned int Antioch::KineticsEvaluator< CoeffType, StateType >::n_species ( ) const

inline

Definition at line 136 of file kinetics_evaluator.h.

   {
     return _chem_mixture.n_species();
   }

template<typename CoeffType , typename StateType >

const ReactionSet< CoeffType > & Antioch::KineticsEvaluator< CoeffType, StateType >::reaction_set ( ) const

inline

Definition at line 129 of file kinetics_evaluator.h.

   {
     return _reaction_set;
   }

Member Data Documentation

template<typename CoeffType = double, typename StateType = CoeffType>

const ChemicalMixture<CoeffType>& Antioch::KineticsEvaluator< CoeffType, StateType >::_chem_mixture

protected

Definition at line 117 of file kinetics_evaluator.h.

template<typename CoeffType = double, typename StateType = CoeffType>

std::vector<StateType> Antioch::KineticsEvaluator< CoeffType, StateType >::_dnet_rate_dT

protected

Definition at line 121 of file kinetics_evaluator.h.

template<typename CoeffType = double, typename StateType = CoeffType>

std::vector<std::vector<StateType> > Antioch::KineticsEvaluator< CoeffType, StateType >::_dnet_rate_dX_s

protected

Definition at line 123 of file kinetics_evaluator.h.

template<typename CoeffType = double, typename StateType = CoeffType>

std::vector<StateType> Antioch::KineticsEvaluator< CoeffType, StateType >::_net_reaction_rates

protected

Definition at line 119 of file kinetics_evaluator.h.

template<typename CoeffType = double, typename StateType = CoeffType>

const ReactionSet<CoeffType>& Antioch::KineticsEvaluator< CoeffType, StateType >::_reaction_set

protected

Definition at line 115 of file kinetics_evaluator.h.

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

src/kinetics/include/antioch/kinetics_evaluator.h

Public Member Functions

Protected Attributes

Detailed Description

template<typename CoeffType = double, typename StateType = CoeffType> class Antioch::KineticsEvaluator< CoeffType, StateType >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename CoeffType = double, typename StateType = CoeffType>
class Antioch::KineticsEvaluator< CoeffType, StateType >