A single reaction mechanism. More...

#include <reaction.h>

Public Member Functions
	Reaction (const unsigned int n_species, const std::string &equation, const bool &reversible=true, const ReactionType::ReactionType type=ReactionType::ELEMENTARY, const KineticsModel::KineticsModel kin=KineticsModel::KOOIJ)
	Construct a single reaction mechanism. More...

virtual	~Reaction ()

unsigned int	n_species () const

const std::string &	equation () const

const std::string &	id () const

void	set_id (const std::string &id)
	set the reaction id. More...

ReactionType::ReactionType	type () const
	Type of reaction. More...

void	set_type (const ReactionType::ReactionType type)
	Set the type of reaction. More...

void	set_reversibility (const bool reversible)
	Set the reversibility of reaction. More...

KineticsModel::KineticsModel	kinetics_model () const
	Model of kinetics. More...

void	set_kinetics_model (const KineticsModel::KineticsModel kin)
	Set the model of kinetics. More...

bool	initialized () const

void	set_parameter_of_rate (KineticsModel::Parameters parameter, CoeffType new_value, unsigned int n_reaction=0, const std::string &unit="SI")
	reset a parameter from the rate constant More...

void	set_parameter_of_rate (KineticsModel::Parameters parameter, CoeffType new_value, unsigned int n_reaction, int l, const std::string &unit="SI")
	reset a parameter from the rate constant, vector parameters More...

CoeffType	get_parameter_of_rate (KineticsModel::Parameters parameter, unsigned int n_reaction=0, const std::string &unit="SI") const
	get a parameter from the rate constant More...

CoeffType	get_parameter_of_rate (KineticsModel::Parameters parameter, unsigned int n_reaction, const std::string &unit, int l) const
	get a parameter from the rate constant, vectorized version More...

void	set_parameter_of_chemical_process (ReactionType::Parameters parameter, CoeffType new_value, unsigned int species=std::numeric_limits< unsigned int >::max())
	reset a parameter from the chemical process More...

CoeffType	get_parameter_of_chemical_process (ReactionType::Parameters parameter, unsigned int species=std::numeric_limits< unsigned int >::max()) const
	get a parameter from the chemical process More...

bool	reversible () const

unsigned int	n_reactants () const

unsigned int	n_products () const

const std::string &	reactant_name (const unsigned int r) const

const std::string &	product_name (const unsigned int p) const

unsigned int	reactant_id (const unsigned int r) const

unsigned int	product_id (const unsigned int p) const

unsigned int	reactant_stoichiometric_coefficient (const unsigned int r) const

unsigned int	product_stoichiometric_coefficient (const unsigned int p) const

CoeffType	reactant_partial_order (const unsigned int r) const

CoeffType	product_partial_order (const unsigned int p) const

void	add_reactant (const std::string &name, const unsigned int r_id, const unsigned int stoichiometric_coeff, const CoeffType partial_order=std::numeric_limits< CoeffType >::infinity())

void	add_product (const std::string &name, const unsigned int p_id, const unsigned int stoichiometric_coeff, const CoeffType partial_order=std::numeric_limits< CoeffType >::infinity())

void	clear_reactant ()

void	clear_product ()

void	set_efficiency (const std::string &, const unsigned int s, const CoeffType efficiency)

CoeffType	get_efficiency (const unsigned int s) const

CoeffType	efficiency (const unsigned int s) const

void	initialize (unsigned int index=0)
	Computes derived quantities. More...

int	gamma () const

template<typename StateType , typename VectorStateType >
StateType	equilibrium_constant (const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R) const

template<typename StateType , typename VectorStateType >
void	equilibrium_constant_and_derivative (const StateType &T, const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R, const VectorStateType &ddT_h_RT_minus_s_R, StateType &keq, StateType &dkeq_dT) const

template<typename StateType , typename VectorStateType >
StateType	compute_forward_rate_coefficient (const VectorStateType &molar_densities, const KineticsConditions< StateType, VectorStateType > &conditions) const

template<typename StateType , typename VectorStateType >
StateType	compute_forward_rate_coefficient (const VectorStateType &molar_densities, const StateType &temp) const

template<typename StateType , typename VectorStateType >
void	compute_forward_rate_coefficient_and_derivatives (const VectorStateType &molar_densities, const KineticsConditions< StateType, VectorStateType > &conditions, StateType &kfwd, StateType &dkfwd_dT, VectorStateType &dkfwd_dX) const

template<typename StateType , typename VectorStateType >
void	compute_forward_rate_coefficient_and_derivatives (const VectorStateType &molar_densities, const StateType &temp, StateType &kfwd, StateType &dkfwd_dT, VectorStateType &dkfwd_dX) const

template<typename StateType , typename VectorStateType >
StateType	compute_rate_of_progress (const VectorStateType &molar_densities, const KineticsConditions< StateType, VectorStateType > &conditions, const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R) const

template<typename StateType , typename VectorStateType >
StateType	compute_rate_of_progress (const VectorStateType &molar_densities, const StateType &temp, const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R) const

template<typename StateType , typename VectorStateType >
void	compute_rate_of_progress_and_derivatives (const VectorStateType &molar_densities, const ChemicalMixture< CoeffType > &, const KineticsConditions< StateType, VectorStateType > &conditions, const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R, const VectorStateType &dh_RT_minus_s_R_dT, StateType &net_reaction_rate, StateType &dnet_rate_dT, VectorStateType &dnet_rate_dX_s) const

template<typename StateType , typename VectorStateType >
void	compute_rate_of_progress_and_derivatives (const VectorStateType &molar_densities, const ChemicalMixture< CoeffType > &chem_mixture, const StateType &temp, const StateType &P0_RT, const VectorStateType &h_RT_minus_s_R, const VectorStateType &dh_RT_minus_s_R_dT, StateType &net_reaction_rate, StateType &dnet_rate_dT, VectorStateType &dnet_rate_dX_s) const

const KineticsType< CoeffType, VectorCoeffType > &	forward_rate (unsigned int ir=0) const
	Return const reference to the forward rate object. More...

KineticsType< CoeffType, VectorCoeffType > &	forward_rate (unsigned int ir=0)
	Return writeable reference to the forward rate object. More...

template<typename FalloffType >
FalloffType &	falloff ()
	Return writeable reference to the falloff object, test type. More...

void	add_forward_rate (KineticsType< CoeffType, VectorCoeffType > *rate)
	Add a forward rate object. More...

void	swap_forward_rates (unsigned int irate, unsigned int jrate)
	Swap two forward rates object. More...

unsigned int	n_rate_constants () const
	Return the number of rate constant objects. More...

void	print (std::ostream &os=std::cout) const
	Formatted print, by default to `std::cout`. More...

Protected Attributes
unsigned int	_n_species

std::string	_id

std::string	_equation

std::vector< std::string >	_reactant_names

std::vector< std::string >	_product_names

std::vector< unsigned int >	_reactant_ids

std::vector< unsigned int >	_product_ids

std::vector< unsigned int >	_reactant_stoichiometry

std::vector< unsigned int >	_product_stoichiometry

std::vector< unsigned int >	_species_reactant_stoichiometry

std::vector< unsigned int >	_species_product_stoichiometry

std::vector< CoeffType >	_species_reactant_partial_order

std::vector< CoeffType >	_species_product_partial_order

std::vector< int >	_species_delta_stoichiometry

int	_gamma

bool	_initialized

bool	_reversible

ReactionType::ReactionType	_type

KineticsModel::KineticsModel	_kintype

std::vector< KineticsType < CoeffType, VectorCoeffType > * >	_forward_rate
	The forward reaction rate modified Arrhenius form. More...

std::vector< CoeffType >	_efficiencies
	efficiencies for three body reactions More...

Private Member Functions
	Reaction ()

Friends
std::ostream &	operator<< (std::ostream &os, const Reaction &rxn)
	Formatted print. More...

Detailed Description

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>
class Antioch::Reaction< CoeffType, VectorCoeffType >

A single reaction mechanism.

A reaction is characterized by the rate constant $k(T,[M])$ , which can be decomposed into a chemical process and a kinetics model:

$k(T,[M]) = \chi([M],\alpha(T))$

with $\chi$ the chemical process and $\alpha$ the kinetics model.

This virtual base is derived for the following processes:

elementary process (ElementaryReaction),
duplicate process (DuplicateReaction),
three body process (ThreeBodyReaction)
falloff processes (FalloffReaction) and falloff three-body processes (FalloffThreeBodyReaction) with:
- Lindemann falloff (LindemannFalloff),
- Troe falloff (TroeFalloff).

This class encapsulates a kinetics model. The choosable kinetics models are

Constant (ConstantRate),
Hercourt Hessen (HercourtEssenRate),
Berthelot (BerthelotRate),
Arrhenius (ArrheniusRate),
Berthelot Hercourt Hessen (BerthelotHercourtEssenRate),
Kooij, or modified Arrhenius (KooijRate),
Van't Hoff (VantHoffRate).

By default, we choose a reversible ElementaryReaction with a KooijRate kinetics model.

Definition at line 108 of file reaction.h.

Constructor & Destructor Documentation

template<typename CoeffType , typename VectorCoeffType >

Antioch::Reaction< CoeffType, VectorCoeffType >::Reaction	(	const unsigned int	n_species,
		const std::string &	equation,
		const bool &	reversible = `true`,
		const ReactionType::ReactionType	type = `ReactionType::ELEMENTARY`,
		const KineticsModel::KineticsModel	kin = `KineticsModel::KOOIJ`
	)

inline

Construct a single reaction mechanism.

Definition at line 691 of file reaction.h.

     : _n_species(n_species),
       _equation(equation),
       _gamma(0),
       _initialized(false),
       _reversible(reversible),
       _type(type),
       _kintype(kin)
   {
      return;
   }

template<typename CoeffType , typename VectorCoeffType >

Antioch::Reaction< CoeffType, VectorCoeffType >::~Reaction ( )

inlinevirtual

Definition at line 710 of file reaction.h.

   {
     for(unsigned int ir = 0; ir < _forward_rate.size(); ir++)
       {
         delete _forward_rate[ir];
       }
 
     return;
   }

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

Antioch::Reaction< CoeffType, VectorCoeffType >::Reaction ( )

private

Member Function Documentation

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::add_forward_rate ( KineticsType< CoeffType, VectorCoeffType > * rate )

inline

Add a forward rate object.

Definition at line 469 of file reaction.h.

Referenced by Antioch::read_reaction_set_data(), and tester().

   {
     _forward_rate.push_back(rate);
     return;
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::add_product	(	const std::string &	name,
		const unsigned int	p_id,
		const unsigned int	stoichiometric_coeff,
		const CoeffType	partial_order = `std::numeric_limits<CoeffType>::infinity()`
	)

inline

Definition at line 605 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::read_reaction_set_data(), and tester().

   {
     antioch_assert_less(p_id, this->n_species());
     _product_names.push_back(name);
     _product_ids.push_back(p_id);
     _product_stoichiometry.push_back(stoichiometric_coeff);
 
    CoeffType order = (partial_order == std::numeric_limits<CoeffType>::infinity() )?static_cast<CoeffType>(stoichiometric_coeff):partial_order;
     _species_product_partial_order.push_back(order);
     return;
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::add_reactant	(	const std::string &	name,
		const unsigned int	r_id,
		const unsigned int	stoichiometric_coeff,
		const CoeffType	partial_order = `std::numeric_limits<CoeffType>::infinity()`
	)

inline

Definition at line 588 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::read_reaction_set_data(), and tester().

   {
     antioch_assert_less(r_id, this->n_species());
     _reactant_names.push_back(name);
     _reactant_ids.push_back(r_id);
     _reactant_stoichiometry.push_back(stoichiometric_coeff);
 
    CoeffType order = (partial_order == std::numeric_limits<CoeffType>::infinity() )?static_cast<CoeffType>(stoichiometric_coeff):partial_order;
     _species_reactant_partial_order.push_back(order);
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::clear_product ( )

inline

Definition at line 631 of file reaction.h.

   {
     _product_names.clear();
     _product_ids.clear();
     _product_stoichiometry.clear();
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::clear_reactant ( )

inline

Definition at line 622 of file reaction.h.

   {
     _reactant_names.clear();
     _reactant_ids.clear();
     _reactant_stoichiometry.clear();
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::Reaction< CoeffType, VectorCoeffType >::compute_forward_rate_coefficient	(	const VectorStateType &	molar_densities,
		const KineticsConditions< StateType, VectorStateType > &	conditions
	)		const

inline

Definition at line 866 of file reaction.h.

References antioch_error, Antioch::ReactionType::DUPLICATE, Antioch::ReactionType::ELEMENTARY, Antioch::ReactionType::LINDEMANN_FALLOFF, Antioch::ReactionType::LINDEMANN_FALLOFF_THREE_BODY, Antioch::KineticsConditions< StateType, VectorStateType >::T(), Antioch::ReactionType::THREE_BODY, Antioch::ReactionType::TROE_FALLOFF, Antioch::ReactionType::TROE_FALLOFF_THREE_BODY, and Antioch::zero_clone().

Referenced by Antioch::ReactionSet< CoeffType >::get_reactive_scheme(), and tester().

   {
     switch(_type)
       {
       case(ReactionType::ELEMENTARY):
         {
           return (static_cast<const ElementaryReaction<CoeffType>*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::DUPLICATE):
         {
           return (static_cast<const DuplicateReaction<CoeffType>*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::THREE_BODY):
         {
           return (static_cast<const ThreeBodyReaction<CoeffType>*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::LINDEMANN_FALLOFF):
         {
           return (static_cast<const FalloffReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::TROE_FALLOFF):
         {
           return (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::LINDEMANN_FALLOFF_THREE_BODY):
         {
           return (static_cast<const FalloffThreeBodyReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       case(ReactionType::TROE_FALLOFF_THREE_BODY):
         {
           return (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient(molar_densities,conditions);
         }
         break;
 
       default:
         {
           antioch_error();
         }
       } // switch(_type)
 
     // Dummy
     return zero_clone(conditions.T());
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::Reaction< CoeffType, VectorCoeffType >::compute_forward_rate_coefficient	(	const VectorStateType &	molar_densities,
		const StateType &	temp
	)		const

inline

Definition at line 927 of file reaction.h.

References antioch_deprecated.

   {
     antioch_deprecated();
     return compute_forward_rate_coefficient
       (molar_densities,
        KineticsConditions<StateType,VectorStateType>(temp));
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::compute_forward_rate_coefficient_and_derivatives	(	const VectorStateType &	molar_densities,
		const KineticsConditions< StateType, VectorStateType > &	conditions,
		StateType &	kfwd,
		StateType &	dkfwd_dT,
		VectorStateType &	dkfwd_dX
	)		const

inline

Definition at line 939 of file reaction.h.

References antioch_error, Antioch::ReactionType::DUPLICATE, Antioch::ReactionType::ELEMENTARY, Antioch::ReactionType::LINDEMANN_FALLOFF, Antioch::ReactionType::LINDEMANN_FALLOFF_THREE_BODY, Antioch::ReactionType::THREE_BODY, Antioch::ReactionType::TROE_FALLOFF, and Antioch::ReactionType::TROE_FALLOFF_THREE_BODY.

   {
     switch(_type)
       {
       case(ReactionType::ELEMENTARY):
         {
           (static_cast<const ElementaryReaction<CoeffType>*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       case(ReactionType::DUPLICATE):
         {
           (static_cast<const DuplicateReaction<CoeffType>*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       case(ReactionType::THREE_BODY):
         {
           (static_cast<const ThreeBodyReaction<CoeffType>*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       case(ReactionType::LINDEMANN_FALLOFF):
         {
           (static_cast<const FalloffReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       case(ReactionType::TROE_FALLOFF):
         {
           (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
 
       case(ReactionType::LINDEMANN_FALLOFF_THREE_BODY):
         {
           (static_cast<const FalloffThreeBodyReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       case(ReactionType::TROE_FALLOFF_THREE_BODY):
         {
           (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->compute_forward_rate_coefficient_and_derivatives(molar_densities,conditions,kfwd,dkfwd_dT,dkfwd_dX);
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(type)
 
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::compute_forward_rate_coefficient_and_derivatives	(	const VectorStateType &	molar_densities,
		const StateType &	temp,
		StateType &	kfwd,
		StateType &	dkfwd_dT,
		VectorStateType &	dkfwd_dX
	)		const

inline

Definition at line 1003 of file reaction.h.

References antioch_deprecated.

   {
     antioch_deprecated();
     return compute_forward_rate_coefficient_and_derivatives
       (molar_densities,
        KineticsConditions<StateType,VectorStateType>(temp),
        kfwd, dkfwd_dT, dkfwd_dX);
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress	(	const VectorStateType &	molar_densities,
		const KineticsConditions< StateType, VectorStateType > &	conditions,
		const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R
	)		const

inline

Definition at line 1020 of file reaction.h.

References Antioch::zero_clone().

Referenced by tester().

   {
     StateType kfwd = this->compute_forward_rate_coefficient(molar_densities,conditions);
     StateType kfwd_times_reactants = kfwd;
 
     // Rfwd
     for (unsigned int ro=0; ro < this->n_reactants(); ro++)
       {
         kfwd_times_reactants     *=
           ant_pow( molar_densities[this->reactant_id(ro)],
             this->reactant_partial_order(ro));
       }
 
     StateType kbkwd_times_products = Antioch::zero_clone(kfwd_times_reactants);
     if(_reversible)
     {
 
       StateType Keq = this->equilibrium_constant( P0_RT, h_RT_minus_s_R );
       kbkwd_times_products = kfwd/Keq;
 
       // Rbkwd
       for (unsigned int po=0; po< this->n_products(); po++)
         {
           kbkwd_times_products     *=
             ant_pow( molar_densities[this->product_id(po)],
               this->product_partial_order(po));
 
         }
     }
 
     return kfwd_times_reactants - kbkwd_times_products;
 
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress	(	const VectorStateType &	molar_densities,
		const StateType &	temp,
		const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R
	)		const

inline

Definition at line 1060 of file reaction.h.

References antioch_deprecated.

   {
     antioch_deprecated();
     return compute_rate_of_progress
       (molar_densities,
        KineticsConditions<StateType,VectorStateType>(temp),
        P0_RT, h_RT_minus_s_R);
   }

template<typename CoeffType, typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress_and_derivatives	(	const VectorStateType &	molar_densities,
		const ChemicalMixture< CoeffType > &	,
		const KineticsConditions< StateType, VectorStateType > &	conditions,
		const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R,
		const VectorStateType &	dh_RT_minus_s_R_dT,
		StateType &	net_reaction_rate,
		StateType &	dnet_rate_dT,
		VectorStateType &	dnet_rate_dX_s
	)		const

inline

Todo:: Should we make this work arrays that get passed in so we aren't allocating/deallocating here?

Todo:: Should we make this work arrays that get passed in so we aren't allocating/deallocating here?

Definition at line 1075 of file reaction.h.

References antioch_assert_equal_to, Antioch::constant_clone(), Antioch::Constants::pi(), Antioch::set_zero(), Antioch::KineticsConditions< StateType, VectorStateType >::T(), and Antioch::zero_clone().

   {
     antioch_assert_equal_to (molar_densities.size(), this->n_species());
 
 // First the forward component, if reversible, compute and add the backward component
 
     StateType kfwd = Antioch::zero_clone(conditions.T());
     StateType dkfwd_dT = Antioch::zero_clone(conditions.T());
     VectorStateType dkfwd_dX_s = Antioch::zero_clone(molar_densities);
     VectorStateType dkbkwd_dX_s = Antioch::zero_clone(molar_densities);
 
     this->compute_forward_rate_coefficient_and_derivatives(molar_densities, conditions, kfwd, dkfwd_dT ,dkfwd_dX_s);
 
     // If users want to use valarrays, then the output reference sizes
     // had better already match the input value sizes...
     StateType dRfwd_dT = Antioch::zero_clone(kfwd);
 
     // We need to construct using an input StateType argument if we
     // want StateType==valarray to have the right sizes
     // valarray compatibility makes this a bit redundant, but not much
     // worse than the previous version
     VectorStateType dRfwd_dX_s(this->n_species(), kfwd);
 
     Antioch::set_zero(dRfwd_dX_s);
 
     // pre-fill the participating species partials with the rates
     for (unsigned int r=0; r< this->n_reactants(); r++)
       {
         dRfwd_dX_s[this->reactant_id(r)] = kfwd;
       }
 
     //init
     StateType facfwd = constant_clone(conditions.T(),1);
     dRfwd_dT = dkfwd_dT;
 
     // Rfwd & derivatives
     for (unsigned int ro=0; ro < this->n_reactants(); ro++)
       {
         const StateType val =
           ant_pow( molar_densities[this->reactant_id(ro)],
             this->reactant_partial_order(ro));
 
         const StateType dval =
           ( static_cast<CoeffType>(this->reactant_stoichiometric_coefficient(ro))*
             ant_pow( molar_densities[this->reactant_id(ro)],
               this->reactant_partial_order(ro) - 1)
             );
 
         facfwd   *= val;
         dRfwd_dT *= val;
 
         for (unsigned int ri=0; ri<this->n_reactants(); ri++)
           {
             dRfwd_dX_s[this->reactant_id(ri)] *= (ri == ro) ? dval : val;
           }
       }
 
     for (unsigned int s = 0; s < this->n_species(); s++)
       {
         dRfwd_dX_s[s] += facfwd * dkfwd_dX_s[s];
       }
 
     net_reaction_rate = facfwd * kfwd;
 
     dnet_rate_dT = dRfwd_dT;
 
     for (unsigned int s = 0; s < this->n_species(); s++)
       {
         dnet_rate_dX_s[s] = dRfwd_dX_s[s];
       }
 
     if(_reversible)
     {
 
     //backward to be computed and added
 
       StateType keq = Antioch::zero_clone(conditions.T());
       StateType dkeq_dT = Antioch::zero_clone(conditions.T());
 
       equilibrium_constant_and_derivative( conditions.T(), P0_RT, h_RT_minus_s_R,
                                            dh_RT_minus_s_R_dT,
                                            keq, dkeq_dT );
 
       const StateType kbkwd = kfwd/keq;
       const StateType dkbkwd_dT = (dkfwd_dT - kbkwd*dkeq_dT)/keq;
       for(unsigned int s = 0; s < this->n_species(); s++)
         {
           dkbkwd_dX_s[s] = dkfwd_dX_s[s]/keq;
         }
 
       // If users want to use valarrays, then the output reference sizes
       // had better already match the input value sizes...
       StateType dRbkwd_dT = Antioch::zero_clone(dkbkwd_dT);
 
       // We need to construct using an input StateType argument if we
       // want StateType==valarray to have the right sizes
       // valarray compatibility makes this a bit redundant, but not much
       // worse than the previous version
       VectorStateType dRbkwd_dX_s(this->n_species(), kbkwd);
 
       Antioch::set_zero(dRbkwd_dX_s);
 
       // pre-fill the participating species partials with the rates
       for (unsigned int p=0; p < this->n_products(); p++)
         {
           dRbkwd_dX_s[this->product_id(p)] = kbkwd;
         }
 
       //init
       StateType facbkwd = constant_clone(conditions.T(),1);
       dRbkwd_dT = dkbkwd_dT;
 
       // Rbkwd & derivatives
       for (unsigned int po=0; po< this->n_products(); po++)
         {
           const StateType val =
             ant_pow( molar_densities[this->product_id(po)],
               this->product_partial_order(po));
 
           const StateType dval =
             ( static_cast<CoeffType>(this->product_stoichiometric_coefficient(po))*
               ant_pow( molar_densities[this->product_id(po)],
               this->product_partial_order(po) - 1)
               );
 
           facbkwd   *= val;
           dRbkwd_dT *= val;
 
           for (unsigned int pi=0; pi<this->n_products(); pi++)
             {
               dRbkwd_dX_s[this->product_id(pi)] *= (pi == po) ? dval : val;
             }
 
         }
 
       for (unsigned int s = 0; s < this->n_species(); s++)
         {
           dRbkwd_dX_s[s] += facbkwd * dkbkwd_dX_s[s];
         }
 
       net_reaction_rate -= facbkwd * kbkwd;
 
       dnet_rate_dT -= dRbkwd_dT;
 
       for (unsigned int s = 0; s < this->n_species(); s++)
         {
           dnet_rate_dX_s[s] -= dRbkwd_dX_s[s];
         }
 
     } //end of if(_reversible) condition
 
     return;
   }

template<typename CoeffType, typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress_and_derivatives	(	const VectorStateType &	molar_densities,
		const ChemicalMixture< CoeffType > &	chem_mixture,
		const StateType &	temp,
		const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R,
		const VectorStateType &	dh_RT_minus_s_R_dT,
		StateType &	net_reaction_rate,
		StateType &	dnet_rate_dT,
		VectorStateType &	dnet_rate_dX_s
	)		const

inline

Definition at line 1242 of file reaction.h.

References antioch_deprecated.

   {
     antioch_deprecated();
     return compute_rate_of_progress_and_derivatives
       (molar_densities, chem_mixture,
        KineticsConditions<StateType,VectorStateType>(temp),
        P0_RT, h_RT_minus_s_R, dh_RT_minus_s_R_dT, net_reaction_rate,
        dnet_rate_dT, dnet_rate_dX_s);
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::efficiency ( const unsigned int s ) const

inline

Definition at line 658 of file reaction.h.

References antioch_assert.

   {
 
     antioch_assert(s < _efficiencies.size());
     return _efficiencies[s];
   }

template<typename CoeffType , typename VectorCoeffType >

const std::string & Antioch::Reaction< CoeffType, VectorCoeffType >::equation ( ) const

inline

Returns: the equation for this reaction.

Definition at line 410 of file reaction.h.

Referenced by Antioch::read_reaction_set_data().

   {
     return _equation;
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::Reaction< CoeffType, VectorCoeffType >::equilibrium_constant	(	const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R
	)		const

inline

Todo:: Make this assertion vector-compatible

Definition at line 751 of file reaction.h.

References antioch_assert, antioch_assert_equal_to, and antioch_assert_greater.

Referenced by Antioch::ReactionSet< CoeffType >::get_reactive_scheme().

   {
     antioch_assert( this->initialized() );
     // antioch_assert_greater( P0_RT, 0.0 );
     antioch_assert_greater( h_RT_minus_s_R.size(), 0 );
     antioch_assert_equal_to( h_RT_minus_s_R.size(), this->n_species() );
 
 
 // DrG0 = - reactants + product
 // K = (P0/(RT))^gamma exp(-DrG0)
 // exppower = -DrG0 = reactants - products
     StateType exppower = ( static_cast<CoeffType>(_reactant_stoichiometry[0])*
                             h_RT_minus_s_R[_reactant_ids[0]] );
 
     for (unsigned int s=1; s < this->n_reactants(); s++)
       {
         exppower += ( static_cast<CoeffType>(_reactant_stoichiometry[s])*
                        h_RT_minus_s_R[_reactant_ids[s]] );
       }
 
     for (unsigned int s=0; s < this->n_products(); s++)
       {
         exppower -= ( static_cast<CoeffType>(_product_stoichiometry[s])*
                        h_RT_minus_s_R[_product_ids[s]] );
       }
     return ant_pow( P0_RT, static_cast<CoeffType>(this->gamma()) ) * ant_exp(exppower);
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::equilibrium_constant_and_derivative	(	const StateType &	T,
		const StateType &	P0_RT,
		const VectorStateType &	h_RT_minus_s_R,
		const VectorStateType &	ddT_h_RT_minus_s_R,
		StateType &	keq,
		StateType &	dkeq_dT
	)		const

inline

Todo:: Make these assertions vector-compatible

Definition at line 785 of file reaction.h.

References antioch_assert, antioch_assert_equal_to, and antioch_assert_greater.

   {
     antioch_assert(this->initialized());
 
     // antioch_assert_greater( P0_RT, 0.0 );
     // antioch_assert_greater( T, 0.0 );
     antioch_assert_greater( h_RT_minus_s_R.size(), 0 );
     antioch_assert_equal_to( h_RT_minus_s_R.size(), this->n_species() );
     antioch_assert_equal_to( ddT_h_RT_minus_s_R.size(), this->n_species() );
 
     // get the equilibrium constant
     keq = this->equilibrium_constant( P0_RT, h_RT_minus_s_R );
 
     StateType ddT_exppower = ( static_cast<CoeffType>(_reactant_stoichiometry[0])*
                                 ddT_h_RT_minus_s_R[_reactant_ids[0]] );
 
     for (unsigned int s=1; s<this->n_reactants(); s++)
       ddT_exppower +=  ( static_cast<CoeffType>(_reactant_stoichiometry[s])*
                          ddT_h_RT_minus_s_R[_reactant_ids[s]] );
 
     for (unsigned int s=0; s<this->n_products(); s++)
       ddT_exppower -=  ( static_cast<CoeffType>(_product_stoichiometry[s])*
                          ddT_h_RT_minus_s_R[_product_ids[s]] );
 
     // compute its derivative
     dkeq_dT = keq*(-static_cast<CoeffType>(this->gamma())/T + ddT_exppower);
 
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

template<typename FalloffType >

FalloffType & Antioch::Reaction< CoeffType, VectorCoeffType >::falloff ( )

inline

Return writeable reference to the falloff object, test type.

Definition at line 1263 of file reaction.h.

References antioch_error, Antioch::ReactionType::LINDEMANN_FALLOFF, Antioch::ReactionType::LINDEMANN_FALLOFF_THREE_BODY, Antioch::ReactionType::TROE_FALLOFF, and Antioch::ReactionType::TROE_FALLOFF_THREE_BODY.

   {
       switch(_type)
       {
         case(ReactionType::LINDEMANN_FALLOFF):
         {
           return (static_cast<const FalloffReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->F();
         }
         break;
 
         case(ReactionType::TROE_FALLOFF):
         {
           return (static_cast<const FalloffReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->F();
         }
         break;
 
         case(ReactionType::LINDEMANN_FALLOFF_THREE_BODY):
         {
           return (static_cast<const FalloffThreeBodyReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->F();
         }
         break;
 
         case(ReactionType::TROE_FALLOFF_THREE_BODY):
         {
           return (static_cast<const FalloffThreeBodyReaction<CoeffType,LindemannFalloff<CoeffType> >*>(this))->F();
         }
         break;
 
         default:
         {
           std::cerr << "You are trying to retrieve a Falloff object in a reaction that is not a falloff.\n"
                     << "The reaction is " << *this << std::endl;
           antioch_error();
           return NULL;
         }
 
       }
   }

template<typename CoeffType , typename VectorCoeffType >

const KineticsType< CoeffType, VectorCoeffType > & Antioch::Reaction< CoeffType, VectorCoeffType >::forward_rate ( unsigned int ir = 0 ) const

inline

Return const reference to the forward rate object.

Definition at line 674 of file reaction.h.

References antioch_assert_less.

   {
     antioch_assert_less(ir,_forward_rate.size());
     return *_forward_rate[ir];
   }

template<typename CoeffType , typename VectorCoeffType >

KineticsType< CoeffType, VectorCoeffType > & Antioch::Reaction< CoeffType, VectorCoeffType >::forward_rate ( unsigned int ir = 0 )

inline

Return writeable reference to the forward rate object.

Definition at line 682 of file reaction.h.

References antioch_assert_less.

   {
     antioch_assert_less(ir,_forward_rate.size());
     return *_forward_rate[ir];
   }

template<typename CoeffType , typename VectorCoeffType >

int Antioch::Reaction< CoeffType, VectorCoeffType >::gamma ( ) const

inline

Definition at line 667 of file reaction.h.

   {
     return _gamma;
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::get_efficiency ( const unsigned int s ) const

inline

Definition at line 650 of file reaction.h.

References antioch_assert_less.

   {
     antioch_assert_less(s, _efficiencies.size());
     return _efficiencies[s];
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::get_parameter_of_chemical_process	(	ReactionType::Parameters	parameter,
		unsigned int	species = `std::numeric_limits<unsigned int>::max()`
	)		const

inline

get a parameter from the chemical process

Definition at line 1415 of file reaction.h.

References antioch_error, Antioch::ReactionType::EFFICIENCIES, Antioch::ReactionType::TROE_ALPHA, Antioch::ReactionType::TROE_FALLOFF, Antioch::ReactionType::TROE_FALLOFF_THREE_BODY, Antioch::ReactionType::TROE_T1, Antioch::ReactionType::TROE_T2, and Antioch::ReactionType::TROE_T3.

   {
       CoeffType value(0);
       switch(parameter)
       {
         case ReactionType::EFFICIENCIES:
         {
           value = this->get_efficiency(species); // tests inside, if not three-body or species wrong
         }
           break;
         case ReactionType::TROE_ALPHA:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              value = (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_alpha();
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              value = (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_alpha();
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T1:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              value = (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T1();
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              value = (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T1();
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T2:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              value = (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T2();
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              value = (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T2();
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T3:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              value = (static_cast<const FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T3();
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              value = (static_cast<const FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().get_T3();
           }else
           {
             antioch_error();
           }
         }
           break;
         default:
         {
           antioch_error();
         }
           break;
       }
 
     return value;
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::get_parameter_of_rate	(	KineticsModel::Parameters	parameter,
		unsigned int	n_reaction = `0`,
		const std::string &	unit = `"SI"`
	)		const

inline

get a parameter from the rate constant

Definition at line 1320 of file reaction.h.

References antioch_assert_less.

   {
       antioch_assert_less(n_reaction,_forward_rate.size());
       return _forward_rate[n_reaction]->get_parameter(parameter);
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::get_parameter_of_rate	(	KineticsModel::Parameters	parameter,
		unsigned int	n_reaction,
		const std::string &	unit,
		int	l
	)		const

inline

get a parameter from the rate constant, vectorized version

Definition at line 1328 of file reaction.h.

References antioch_assert_less.

   {
       antioch_assert_less(n_reaction,_forward_rate.size());
       return _forward_rate[n_reaction]->get_parameter(parameter,l);
   }

template<typename CoeffType , typename VectorCoeffType >

const std::string & Antioch::Reaction< CoeffType, VectorCoeffType >::id ( ) const

inline

Returns: the reaction id.

Definition at line 396 of file reaction.h.

   {
     return _id;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::initialize ( unsigned int index = 0 )

inline

Computes derived quantities.

Definition at line 723 of file reaction.h.

Referenced by tester().

   {
     _gamma = 0;
     for (unsigned int r=0; r< this->n_reactants(); r++)
       {
         _gamma -= this->reactant_stoichiometric_coefficient(r);
       }
 
     for (unsigned int p=0; p < this->n_products(); p++)
       {
         _gamma += this->product_stoichiometric_coefficient(p);
       }
 
      // gives kinetics object index in reaction set
      for(typename std::vector<KineticsType<CoeffType,VectorCoeffType>* >::iterator it = _forward_rate.begin();
                 it != _forward_rate.end(); it++)
      {
         (*it)->set_index(index);
      }
 
     // set initialization flag
     _initialized = true;
   }

template<typename CoeffType , typename VectorCoeffType >

bool Antioch::Reaction< CoeffType, VectorCoeffType >::initialized ( ) const

inline

Definition at line 455 of file reaction.h.

   {
     return _initialized;
   }

template<typename CoeffType , typename VectorCoeffType >

KineticsModel::KineticsModel Antioch::Reaction< CoeffType, VectorCoeffType >::kinetics_model ( ) const

inline

Model of kinetics.

Definition at line 440 of file reaction.h.

   {
     return _kintype;
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::n_products ( ) const

inline

Returns: the number of products.

Definition at line 508 of file reaction.h.

References antioch_assert_equal_to, and antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), Antioch::ReactionSet< CoeffType >::get_reactive_scheme(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(_product_ids.size(), this->n_species());
     antioch_assert_equal_to(_product_ids.size(), _product_stoichiometry.size());
     antioch_assert_equal_to(_product_ids.size(),  _product_names.size());
     return _product_ids.size();
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::n_rate_constants ( ) const

inline

Return the number of rate constant objects.

Definition at line 477 of file reaction.h.

Referenced by Antioch::read_reaction_set_data().

   {
     return _forward_rate.size();
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::n_reactants ( ) const

inline

Returns: the number of reactants.

Definition at line 498 of file reaction.h.

References antioch_assert_equal_to, and antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), Antioch::ReactionSet< CoeffType >::get_reactive_scheme(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(_reactant_ids.size(), this->n_species());
     antioch_assert_equal_to(_reactant_ids.size(), _reactant_stoichiometry.size());
     antioch_assert_equal_to(_reactant_ids.size(), _reactant_names.size());
     return _reactant_ids.size();
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::n_species ( ) const

inline

Definition at line 389 of file reaction.h.

   {
     return _n_species;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::print ( std::ostream & os = std::cout ) const

inline

Formatted print, by default to std::cout.

Definition at line 824 of file reaction.h.

References Antioch::ReactionType::LINDEMANN_FALLOFF_THREE_BODY, Antioch::ReactionType::THREE_BODY, and Antioch::ReactionType::TROE_FALLOFF_THREE_BODY.

Referenced by tester().

   {
     os << "# Gas-Phase Reaction \"" << _equation << "\":\n";
     if (this->n_species())
       {
         os << "#   reactants: ";
         for (unsigned int r=0; r<this->n_reactants(); r++)
           os << this->reactant_name(r) << ":"
              << this->reactant_stoichiometric_coefficient(r) << ","
              << this->reactant_partial_order(r) << " ";
         os << "\n"
            << "#   products:  ";
         for (unsigned int p=0; p<this->n_products(); p++)
           os << this->product_name(p) << ":"
              << this->product_stoichiometric_coefficient(p) << ","
              << this->product_partial_order(p) << " ";
       }
     os << "\n#   Chemical process: " << _type;
     os << "\n#   Kinetics model: "   << _kintype;
     (_reversible)?os << "\n#   reversible":
                   os << "\n#   irreversible";
     for(unsigned int ir = 0; ir < _forward_rate.size(); ir++)
       {
         os << "\n#   forward rate eqn: " << *_forward_rate[ir];
       }
 
     if (_type == ReactionType::THREE_BODY ||
         _type == ReactionType::LINDEMANN_FALLOFF_THREE_BODY ||
         _type == ReactionType::TROE_FALLOFF_THREE_BODY)
       {
         os << "\n#   efficiencies: ";
         for (unsigned int s=0; s<this->n_species(); s++)
           os << s << ":" << this->efficiency(s) << " ";
       }
     os << "\n#";
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::product_id ( const unsigned int p ) const

inline

Definition at line 543 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), Antioch::ReactionSet< CoeffType >::get_reactive_scheme(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(p, _product_ids.size());
     antioch_assert_less(_product_ids[p], this->n_species());
     return _product_ids[p];
   }

template<typename CoeffType , typename VectorCoeffType >

const std::string & Antioch::Reaction< CoeffType, VectorCoeffType >::product_name ( const unsigned int p ) const

inline

Returns: the name of the p th product.

Definition at line 526 of file reaction.h.

References antioch_assert_less.

   {
     antioch_assert_less(p, _product_names.size());
     return _product_names[p];
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::product_partial_order ( const unsigned int p ) const

inline

Definition at line 579 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::ReactionSet< CoeffType >::get_reactive_scheme().

   {
     antioch_assert_less(p, _species_product_partial_order.size());
     antioch_assert_less(_product_ids[p], this->n_species());
     return _species_product_partial_order[p];
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::product_stoichiometric_coefficient ( const unsigned int p ) const

inline

Definition at line 561 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(p, _product_stoichiometry.size());
     antioch_assert_less(_product_ids[p], this->n_species());
     return _product_stoichiometry[p];
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_id ( const unsigned int r ) const

inline

Definition at line 534 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), Antioch::ReactionSet< CoeffType >::get_reactive_scheme(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(r, _reactant_ids.size());
     antioch_assert_less(_reactant_ids[r], this->n_species());
     return _reactant_ids[r];
   }

template<typename CoeffType , typename VectorCoeffType >

const std::string & Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_name ( const unsigned int r ) const

inline

Returns: the name of the r th reactant.

Definition at line 518 of file reaction.h.

References antioch_assert_less.

   {
     antioch_assert_less(r, _reactant_names.size());
     return _reactant_names[r];
   }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_partial_order ( const unsigned int r ) const

inline

Definition at line 570 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::ReactionSet< CoeffType >::get_reactive_scheme().

   {
     antioch_assert_less(r, _species_reactant_partial_order.size());
     antioch_assert_less(_reactant_ids[r], this->n_species());
     return _species_reactant_partial_order[r];
   }

template<typename CoeffType , typename VectorCoeffType >

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::reactant_stoichiometric_coefficient ( const unsigned int r ) const

inline

Definition at line 552 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), and Antioch::ReactionSet< CoeffType >::print_chemical_scheme().

   {
     antioch_assert_less(r, _reactant_stoichiometry.size());
     antioch_assert_less(_reactant_ids[r], this->n_species());
     return _reactant_stoichiometry[r];
   }

template<typename CoeffType , typename VectorCoeffType >

bool Antioch::Reaction< CoeffType, VectorCoeffType >::reversible ( ) const

inline

Returns: the reversibility state of reaction.

Definition at line 462 of file reaction.h.

Referenced by Antioch::ReactionSet< CoeffType >::get_reactive_scheme().

   {
     return _reversible;
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_efficiency	(	const std::string &	,
		const unsigned int	s,
		const CoeffType	efficiency
	)

inline

Definition at line 640 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::read_reaction_set_data().

   {
     antioch_assert_less(s, _efficiencies.size());
     _efficiencies[s] = efficiency;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_id ( const std::string & id )

inline

set the reaction id.

Definition at line 403 of file reaction.h.

Referenced by Antioch::read_reaction_set_data().

   {
     _id = id;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_kinetics_model ( const KineticsModel::KineticsModel kin )

inline

Set the model of kinetics.

Definition at line 447 of file reaction.h.

   {
     _kintype = kin;
     return;
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_parameter_of_chemical_process	(	ReactionType::Parameters	parameter,
		CoeffType	new_value,
		unsigned int	species = `std::numeric_limits<unsigned int>::max()`
	)

inline

reset a parameter from the chemical process

Definition at line 1336 of file reaction.h.

References antioch_error, Antioch::ReactionType::EFFICIENCIES, Antioch::ReactionType::TROE_ALPHA, Antioch::ReactionType::TROE_FALLOFF, Antioch::ReactionType::TROE_FALLOFF_THREE_BODY, Antioch::ReactionType::TROE_T1, Antioch::ReactionType::TROE_T2, and Antioch::ReactionType::TROE_T3.

   {
       switch(parameter)
       {
         case ReactionType::EFFICIENCIES:
         {
           this->set_efficiency(std::string(),species,new_value); // tests inside, if not three-body or species wrong
         }
           break;
         case ReactionType::TROE_ALPHA:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              (static_cast<FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_alpha(new_value);
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              (static_cast<FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_alpha(new_value);
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T1:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              (static_cast<FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T1(new_value);
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              (static_cast<FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T1(new_value);
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T2:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              (static_cast<FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T2(new_value);
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              (static_cast<FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T2(new_value);
           }else
           {
             antioch_error();
           }
         }
           break;
         case ReactionType::TROE_T3:
         {
           if(this->type() == ReactionType::TROE_FALLOFF)
           {
              (static_cast<FalloffReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T3(new_value);
           }
           else if(this->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
              (static_cast<FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >*>(this))->F().set_T3(new_value);
           }else
           {
             antioch_error();
           }
         }
           break;
         default:
         {
           antioch_error();
         }
           break;
       }
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_parameter_of_rate	(	KineticsModel::Parameters	parameter,
		CoeffType	new_value,
		unsigned int	n_reaction = `0`,
		const std::string &	unit = `"SI"`
	)

inline

reset a parameter from the rate constant

Definition at line 1304 of file reaction.h.

References antioch_assert_less, and Antioch::reset_parameter_of_rate().

   {
       antioch_assert_less(n_kin,_forward_rate.size());
       reset_parameter_of_rate(*_forward_rate[n_kin], parameter, new_value, unit);
   }

template<typename CoeffType, typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_parameter_of_rate	(	KineticsModel::Parameters	parameter,
		CoeffType	new_value,
		unsigned int	n_reaction,
		int	l,
		const std::string &	unit = `"SI"`
	)

inline

reset a parameter from the rate constant, vector parameters

Definition at line 1312 of file reaction.h.

References antioch_assert_less, and Antioch::reset_parameter_of_rate().

   {
       antioch_assert_less(n_kin,_forward_rate.size());
       reset_parameter_of_rate(*_forward_rate[n_kin], parameter, new_value, l, unit);
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_reversibility ( const bool reversible )

inline

Set the reversibility of reaction.

Definition at line 432 of file reaction.h.

Referenced by tester().

   {
     _reversible = reversible;
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::set_type ( const ReactionType::ReactionType type )

inline

Set the type of reaction.

reversible reactions are considered.

Definition at line 424 of file reaction.h.

   {
     _type = type;
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::Reaction< CoeffType, VectorCoeffType >::swap_forward_rates	(	unsigned int	irate,
		unsigned int	jrate
	)

inline

Swap two forward rates object.

Definition at line 484 of file reaction.h.

References antioch_assert_less.

Referenced by Antioch::read_reaction_set_data().

   {
     antioch_assert_less(irate,_forward_rate.size());
     antioch_assert_less(jrate,_forward_rate.size());
 
     KineticsType<CoeffType>* rate_tmp = _forward_rate[jrate];
     _forward_rate[jrate] = _forward_rate[irate];
     _forward_rate[irate] = rate_tmp;
 
     return;
   }

template<typename CoeffType , typename VectorCoeffType >

ReactionType::ReactionType Antioch::Reaction< CoeffType, VectorCoeffType >::type ( ) const

inline

Type of reaction.

reversible reactions are considered.

Definition at line 417 of file reaction.h.

Referenced by Antioch::read_reaction_set_data().

   {
     return _type;
   }

Friends And Related Function Documentation

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::ostream& operator<<	(	std::ostream &	os,
		const Reaction< CoeffType, VectorCoeffType > &	rxn
	)

friend

Formatted print.

Definition at line 347 of file reaction.h.

     {
       rxn.print(os);
       return os;
     }

Member Data Documentation

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<CoeffType> Antioch::Reaction< CoeffType, VectorCoeffType >::_efficiencies

protected

efficiencies for three body reactions

Definition at line 379 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::string Antioch::Reaction< CoeffType, VectorCoeffType >::_equation

protected

Definition at line 357 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<KineticsType<CoeffType,VectorCoeffType>* > Antioch::Reaction< CoeffType, VectorCoeffType >::_forward_rate

protected

The forward reaction rate modified Arrhenius form.

Definition at line 376 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

int Antioch::Reaction< CoeffType, VectorCoeffType >::_gamma

protected

Definition at line 369 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::string Antioch::Reaction< CoeffType, VectorCoeffType >::_id

protected

Definition at line 356 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

bool Antioch::Reaction< CoeffType, VectorCoeffType >::_initialized

protected

Definition at line 370 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

KineticsModel::KineticsModel Antioch::Reaction< CoeffType, VectorCoeffType >::_kintype

protected

Definition at line 373 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

unsigned int Antioch::Reaction< CoeffType, VectorCoeffType >::_n_species

protected

Definition at line 355 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_product_ids

protected

Definition at line 361 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<std::string> Antioch::Reaction< CoeffType, VectorCoeffType >::_product_names

protected

Definition at line 359 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_product_stoichiometry

protected

Definition at line 363 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_reactant_ids

protected

Definition at line 360 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<std::string> Antioch::Reaction< CoeffType, VectorCoeffType >::_reactant_names

protected

Definition at line 358 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_reactant_stoichiometry

protected

Definition at line 362 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

bool Antioch::Reaction< CoeffType, VectorCoeffType >::_reversible

protected

Definition at line 371 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<int> Antioch::Reaction< CoeffType, VectorCoeffType >::_species_delta_stoichiometry

protected

Definition at line 368 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<CoeffType> Antioch::Reaction< CoeffType, VectorCoeffType >::_species_product_partial_order

protected

Definition at line 367 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_species_product_stoichiometry

protected

Definition at line 365 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<CoeffType> Antioch::Reaction< CoeffType, VectorCoeffType >::_species_reactant_partial_order

protected

Definition at line 366 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

std::vector<unsigned int> Antioch::Reaction< CoeffType, VectorCoeffType >::_species_reactant_stoichiometry

protected

Definition at line 364 of file reaction.h.

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>

ReactionType::ReactionType Antioch::Reaction< CoeffType, VectorCoeffType >::_type

protected

Definition at line 372 of file reaction.h.

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

src/kinetics/include/antioch/reaction.h

Public Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>> class Antioch::Reaction< CoeffType, VectorCoeffType >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename CoeffType = double, typename VectorCoeffType = std::vector<CoeffType>>
class Antioch::Reaction< CoeffType, VectorCoeffType >