Antioch::PhotochemicalRate< CoeffType, VectorCoeffType > Class Template Reference

Photochemical rate. More...

#include <kinetics_type.h>

Inheritance diagram for Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >:

Public Member Functions
	PhotochemicalRate (const VectorCoeffType &cs, const VectorCoeffType &lambda)
	PhotochemicalRate ()
	~PhotochemicalRate ()
VectorCoeffType	cross_section () const
VectorCoeffType	lambda_grid () const
void	set_cross_section (const VectorCoeffType &cs)
void	set_lambda_grid (const VectorCoeffType &l)
void	set_cross_section (CoeffType cs, int il)
void	set_lambda_grid (CoeffType l, int il)
void	set_parameter (KineticsModel::Parameters parameter, int l, CoeffType new_value)
	set one value of one parameter, characterized by enum and its index More...
CoeffType	get_parameter (KineticsModel::Parameters parameter, int l) const
	set one parameter, characterized by enum More...
void	reset_coefs (const VectorCoeffType &coefficients)
	reset the coefficients More...
template<typename VectorStateType >
void	calculate_rate_constant (const VectorStateType &hv_flux, const VectorStateType &hv_lambda, bool x_update=true)
	calculate _k for a given photon flux More...
const std::string	numeric () const
	print equation More...
KineticsModel::KineticsModel	type () const
template<typename StateType , typename VectorStateType >
StateType	operator() (const KineticsConditions< StateType, VectorStateType > &conditions) const
template<typename StateType >
StateType	operator() (const StateType &temp) const
template<typename StateType , typename VectorStateType >
StateType	derivative (const KineticsConditions< StateType, VectorStateType > &conditions) const
template<typename StateType >
StateType	derivative (const StateType &conditions) const
CoeffType	get_parameter (KineticsModel::Parameters parameter) const
	get one parameter, characterized by enum More...
template<typename StateType , typename VectorStateType >
void	compute_rate_and_derivative (const KineticsConditions< StateType, VectorStateType > &conditions, StateType &rate, StateType &drate_dT) const
template<typename StateType >
void	compute_rate_and_derivative (const StateType &temp, StateType &rate, StateType &drate_dT) const
void	set_index (unsigned int nr)
void	print (std::ostream &os=std::cout) const
	Formatted print, by default to std::cout. More...

Public Attributes
template<typename VectorStateType >
operator()(const ParticleFlux < VectorStateType > &pf) const template< typename VectorStateType > typename value_type< VectorStateType >	derivative (const ParticleFlux< VectorStateType > &) const template< typename StateType
	Simultaneously evaluate the rate and its derivative at T. More...
operator()(const ParticleFlux < VectorStateType > &pf) const template< typename VectorStateType > typename value_type< VectorStateType > VectorStateType void	rate_and_derivative (const ParticleFlux< VectorStateType > &pf, StateType &rate, StateType &drate_dT) const

Private Attributes
VectorCoeffType	_cross_section
VectorCoeffType	_lambda_grid
SigmaBinConverter < VectorCoeffType >	_converter

Detailed Description

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

Photochemical rate.

Todo:

Need to find a place to store k once calculated, and recalculate only if the photon flux has changed. Might want also to re-put _cross_section_on_flux_grid, as usually, changes will appear in the photon flux, not the lambda grid.

Definition at line 65 of file kinetics_type.h.

Constructor & Destructor Documentation

template<typename CoeffType , typename VectorCoeffType >

Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::PhotochemicalRate ( const VectorCoeffType &  cs, const VectorCoeffType &  lambda  )

inline

Definition at line 128 of file photochemical_rate.h.

                                                                                                :
    KineticsType<CoeffType,VectorCoeffType>(KineticsModel::PHOTOCHEM),
    _cross_section(cs),
    _lambda_grid(lambda)
  {
    return;
  }

template<typename CoeffType , typename VectorCoeffType >

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

inline

Definition at line 139 of file photochemical_rate.h.

                                                                 :
    KineticsType<CoeffType,VectorCoeffType>(KineticsModel::PHOTOCHEM)
  {
    return;
  }

template<typename CoeffType , typename VectorCoeffType >

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

inline

Definition at line 147 of file photochemical_rate.h.

  {
    return;
  }

Member Function Documentation

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

template<typename VectorStateType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::calculate_rate_constant	(	const VectorStateType &	hv_flux,
		const VectorStateType &	hv_lambda,
		bool	x_update = true
	)

calculate _k for a given photon flux

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

void Antioch::KineticsType< CoeffType, VectorCoeffType >::compute_rate_and_derivative ( const KineticsConditions< StateType, VectorStateType > &  conditions, StateType &  rate, StateType &  drate_dT  ) const

inlineinherited

Definition at line 336 of file kinetics_type.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsConditions< StateType, VectorStateType >::particle_flux(), Antioch::KineticsModel::PHOTOCHEM, and Antioch::KineticsModel::VANTHOFF.

Referenced by test_values().

  {
    switch (my_type) 
      {
      case(KineticsModel::CONSTANT):
        {
          (static_cast<const ConstantRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::HERCOURT_ESSEN):
        {
          (static_cast<const HercourtEssenRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::BERTHELOT):
        {
          (static_cast<const BerthelotRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::ARRHENIUS):
        {
          (static_cast<const ArrheniusRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::BHE):
        {
          (static_cast<const BerthelotHercourtEssenRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::KOOIJ):
        {
          (static_cast<const KooijRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::VANTHOFF):
        {
          (static_cast<const VantHoffRate<CoeffType>*>(this))->rate_and_derivative(conditions,rate,drate_dT);
        }
        break;

      case(KineticsModel::PHOTOCHEM):
        {
          (static_cast<const PhotochemicalRate<CoeffType,VectorCoeffType>*>(this))->rate_and_derivative(conditions.particle_flux(my_index),rate,drate_dT);
        }
        break;

      default:
        {
          antioch_error();
        }

      } // switch(my_type)
    
    return;
  }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType >

void Antioch::KineticsType< CoeffType, VectorCoeffType >::compute_rate_and_derivative ( const StateType &  temp, StateType &  rate, StateType &  drate_dT  ) const

inlineinherited

Definition at line 482 of file kinetics_type.h.

References antioch_deprecated.

  {
    antioch_deprecated();
    return compute_rate_and_derivative
      (KineticsConditions<StateType> (temp), rate, drate_dT);
  }

template<typename CoeffType , typename VectorCoeffType >

VectorCoeffType Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::cross_section ( ) const

inline

Definition at line 308 of file photochemical_rate.h.

  {
     return _cross_section;
  }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::KineticsType< CoeffType, VectorCoeffType >::derivative ( const KineticsConditions< StateType, VectorStateType > &  conditions ) const

inlineinherited

Definition at line 259 of file kinetics_type.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsConditions< StateType, VectorStateType >::particle_flux(), Antioch::KineticsModel::PHOTOCHEM, Antioch::KineticsConditions< StateType, VectorStateType >::T(), Antioch::KineticsModel::VANTHOFF, and Antioch::zero_clone().

Referenced by test_values().

  {
    switch(my_type) 
      {
      case(KineticsModel::CONSTANT):
        {
          return (static_cast<const ConstantRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::HERCOURT_ESSEN):
        {
          return (static_cast<const HercourtEssenRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::BERTHELOT):
        {
          return (static_cast<const BerthelotRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::ARRHENIUS):
        {
          return (static_cast<const ArrheniusRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::BHE):
        {
          return (static_cast<const BerthelotHercourtEssenRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::KOOIJ):
        {
          return (static_cast<const KooijRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::VANTHOFF):
        {
          return (static_cast<const VantHoffRate<CoeffType>*>(this))->derivative(conditions);
        }
        break;

      case(KineticsModel::PHOTOCHEM):
        {
          return (static_cast<const PhotochemicalRate<CoeffType,VectorCoeffType>*>(this))->derivative(conditions.particle_flux(my_index)); 
        }
        break;

      default:
        {
          antioch_error();
        }

      } // switch(my_type)

    // Dummy
    return zero_clone(conditions.T());
  }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType >

StateType Antioch::KineticsType< CoeffType, VectorCoeffType >::derivative ( const StateType &  conditions ) const

inlineinherited

Definition at line 326 of file kinetics_type.h.

References antioch_deprecated.

  {
    antioch_deprecated();
    return derivative
      ( KineticsConditions<StateType> (temp) );
  }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::get_parameter ( KineticsModel::Parameters  parameter, int  l  ) const

inline

set one parameter, characterized by enum

Definition at line 229 of file photochemical_rate.h.

References antioch_assert_less, antioch_error, Antioch::KineticsModel::LAMBDA, and Antioch::KineticsModel::SIGMA.

  {

   antioch_assert_less(l,_cross_section.size());

    switch(parameter)
    {
      case KineticsModel::Parameters::LAMBDA:
      {
         return this->lambda_grid()[l];
      }
       break;
      case KineticsModel::Parameters::SIGMA:
      {
         return this->cross_section()[l];
      }
        break;
      default:
      {
        antioch_error();
      }
       break;
    }

     return 0;
  }

template<typename CoeffType , typename VectorCoeffType >

CoeffType Antioch::KineticsType< CoeffType, VectorCoeffType >::get_parameter ( KineticsModel::Parameters  parameter ) const

inherited

get one parameter, characterized by enum

Definition at line 400 of file kinetics_type.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, and Antioch::KineticsModel::VANTHOFF.

  {
    switch (my_type) 
      {
      case(KineticsModel::CONSTANT):
        {
          return (static_cast<const ConstantRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::HERCOURT_ESSEN):
        {
          return (static_cast<const HercourtEssenRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::BERTHELOT):
        {
          return (static_cast<const BerthelotRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::ARRHENIUS):
        {
          return (static_cast<const ArrheniusRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::BHE):
        {
          return (static_cast<const BerthelotHercourtEssenRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::KOOIJ):
        {
          return (static_cast<const KooijRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      case(KineticsModel::VANTHOFF):
        {
          return (static_cast<const VantHoffRate<CoeffType>*>(this))->get_parameter(parameter);
        }
        break;

      default:
        {
          antioch_error();
        }

      } // switch(my_type)

      return 0;
  }

template<typename CoeffType , typename VectorCoeffType >

VectorCoeffType Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::lambda_grid ( ) const

inline

Definition at line 315 of file photochemical_rate.h.

  {
     return _lambda_grid;
  }

template<typename CoeffType , typename VectorCoeffType >

const std::string Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::numeric ( ) const

inlinevirtual

print equation

Implements Antioch::KineticsType< CoeffType, VectorCoeffType >.

Definition at line 287 of file photochemical_rate.h.

  {
    std::stringstream os;
    os << "int_0^infty sigma(lambda) * hv(lambda) * dlambda";

    return os.str();
  }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType , typename VectorStateType >

StateType Antioch::KineticsType< CoeffType, VectorCoeffType >::operator() ( const KineticsConditions< StateType, VectorStateType > &  conditions ) const

inlineinherited

Definition at line 182 of file kinetics_type.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsConditions< StateType, VectorStateType >::particle_flux(), Antioch::KineticsModel::PHOTOCHEM, Antioch::KineticsConditions< StateType, VectorStateType >::T(), Antioch::KineticsModel::VANTHOFF, and Antioch::zero_clone().

  {
    switch(my_type) 
      {
      case(KineticsModel::CONSTANT):
        {
          return (static_cast<const ConstantRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::HERCOURT_ESSEN):
        {
          return (static_cast<const HercourtEssenRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::BERTHELOT):
        {
          return (static_cast<const BerthelotRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::ARRHENIUS):
        {
          return (static_cast<const ArrheniusRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::BHE):
        {
          return (static_cast<const BerthelotHercourtEssenRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::KOOIJ):
        {
          return (static_cast<const KooijRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::VANTHOFF):
        {
          return (static_cast<const VantHoffRate<CoeffType>*>(this))->rate(conditions);
        }
        break;

      case(KineticsModel::PHOTOCHEM):
        {
          return (static_cast<const PhotochemicalRate<CoeffType,VectorCoeffType>*>(this))->rate(conditions.particle_flux(my_index));
        }
        break;

      default:
        {
          antioch_error();
        }

      } // switch(my_type)

    // Dummy
    return zero_clone(conditions.T());
  }

template<typename CoeffType , typename VectorCoeffType >

template<typename StateType >

StateType Antioch::KineticsType< CoeffType, VectorCoeffType >::operator() ( const StateType &  temp ) const

inlineinherited

Definition at line 249 of file kinetics_type.h.

References antioch_deprecated.

  {
    antioch_deprecated();
    return operator()
      (KineticsConditions<StateType>(temp) );
  }

template<typename CoeffType , typename VectorCoeffType >

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

inlineinherited

Formatted print, by default to std::cout.

Definition at line 144 of file kinetics_type.h.

  {
    os << numeric();
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::reset_coefs ( const VectorCoeffType &  coefficients )

inline

reset the coefficients

Contrary to the other rate models, no choice here in the VectorCoeffType type. The order assumed is lambda, cross-section

Definition at line 185 of file photochemical_rate.h.

References antioch_assert_equal_to.

  {
      // we require the two vectors being the same size
      antioch_assert_equal_to(coefficients.size()%2,0);

      const unsigned int subsize(coefficients.size()/2);
      VectorCoeffType l(subsize);
      VectorCoeffType cs(subsize);
      for(unsigned int il = 0; il < subsize; il++)
      {
          l[il] = coefficients[il];
          cs[il] = coefficients[il + subsize];
      }
      this->set_lambda_grid(l);
      this->set_cross_section(cs);
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::set_cross_section ( const VectorCoeffType &  cs )

inline

Definition at line 154 of file photochemical_rate.h.

  {
    _cross_section = cs;
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::set_cross_section ( CoeffType  cs, int  il  )

inline

Definition at line 167 of file photochemical_rate.h.

References antioch_assert_less.

  {
     antioch_assert_less(il,_cross_section.size());

    _cross_section[il] = cs;
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::KineticsType< CoeffType, VectorCoeffType >::set_index ( unsigned int  nr )

inlineinherited

Definition at line 174 of file kinetics_type.h.

  {
    my_index = nr;
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::set_lambda_grid ( const VectorCoeffType &  l )

inline

Definition at line 161 of file photochemical_rate.h.

  {
     _lambda_grid = l;
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::set_lambda_grid ( CoeffType  l, int  il  )

inline

Definition at line 176 of file photochemical_rate.h.

References antioch_assert_less.

  {
     antioch_assert_less(il,_lambda_grid.size());

     _lambda_grid[il] = l;
  }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::set_parameter ( KineticsModel::Parameters  parameter, int  l, CoeffType  new_value  )

inline

set one value of one parameter, characterized by enum and its index

Definition at line 204 of file photochemical_rate.h.

References antioch_error, Antioch::KineticsModel::LAMBDA, and Antioch::KineticsModel::SIGMA.

Referenced by tester().

  {

    switch(parameter)
    {
      case KineticsModel::Parameters::LAMBDA:
      {
         this->set_lambda_grid(new_value,l);
      }
       break;
      case KineticsModel::Parameters::SIGMA:
      {
         this->set_cross_section(new_value,l);
      }
        break;
      default:
      {
        antioch_error();
      }
       break;
    }
  }

template<typename CoeffType , typename VectorCoeffType >

KineticsModel::KineticsModel Antioch::KineticsType< CoeffType, VectorCoeffType >::type ( ) const

inlineinherited

Definition at line 160 of file kinetics_type.h.

Referenced by Antioch::reset_parameter_of_rate(), and Antioch::reset_rate().

  {
    return my_type;
  }

Member Data Documentation

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

SigmaBinConverter<VectorCoeffType> Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::_converter

private

Definition at line 59 of file photochemical_rate.h.

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

VectorCoeffType Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::_cross_section

private

Definition at line 57 of file photochemical_rate.h.

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

VectorCoeffType Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::_lambda_grid

private

Definition at line 58 of file photochemical_rate.h.

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

template<typename VectorStateType >

operator() (const ParticleFlux<VectorStateType> & pf) const template <typename VectorStateType> typename value_type<VectorStateType> Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::derivative(const ParticleFlux< VectorStateType > &) const template< typename StateType

Simultaneously evaluate the rate and its derivative at T.

Returns

the rate

the rate evaluated at the given photon spectrum.

the derivative with respect to temperature.

Definition at line 114 of file photochemical_rate.h.

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

void Antioch::PhotochemicalRate< CoeffType, VectorCoeffType >::rate_and_derivative

inline

Definition at line 119 of file photochemical_rate.h.

---

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

• src/kinetics/include/antioch/kinetics_type.h
• src/kinetics/include/antioch/photochemical_rate.h