TwoTempPlasmaRate.h

Go to the documentation of this file.

//! @file TwoTempPlasmaRate.h   Header for plasma reaction rates parameterized by two
//!     temperatures (gas and electron).
 
// This file is part of Cantera. See License.txt in the top-level directory or
// at https://cantera.org/license.txt for license and copyright information.
 
#ifndef CT_TWOTEMPPLASMARATE_H
#define CT_TWOTEMPPLASMARATE_H
 
#include "Arrhenius.h"
 
namespace Cantera
{
 
//! Data container holding shared data specific to TwoTempPlasmaRate.
/**
 * The data container `TwoTempPlasmaData` holds precalculated data common to
 * all `TwoTempPlasmaRate` objects.
 */
struct TwoTempPlasmaData : public ReactionData
{
    TwoTempPlasmaData() = default;
 
    bool update(const ThermoPhase& phase, const Kinetics& kin) override;
    void update(double T) override;
    void update(double T, double Te) override;
    using ReactionData::update;
 
    virtual void updateTe(double Te);
 
    void invalidateCache() override {
        ReactionData::invalidateCache();
        electronTemp = NAN;
    }
 
    double electronTemp = 1.0; //!< electron temperature
    double logTe = 0.0; //!< logarithm of electron temperature
    double recipTe = 1.0; //!< inverse of electron temperature
};
 
//! Two temperature plasma reaction rate type depends on both
//! gas temperature and electron temperature.
/*!
 * The form of the two temperature plasma reaction rate coefficient is similar to an
 * Arrhenius reaction rate coefficient. The temperature exponent (b) is applied to
 * the electron temperature instead. In addition, the exponential term with
 * activation energy for electron is included.
 *
 *   @f[
 *        k_f = A T^{b_g} T_e^b
 *              \exp\left(-\frac{E_{a,g}}{RT}\right)
 *              \exp\left(\frac{E_{a,e}(T_e - T)}{R T T_e}\right)
 *              \exp\left(-\frac{T}{T_\mathrm{inv}}\right)
 *   @f]
 *
 * where @f$ T_e @f$ is the electron temperature, @f$ E_{a,g} @f$ is the activation
 * energy for gas, and @f$ E_{a,e} @f$ is the activation energy for electron, see
 * Kossyi, et al. @cite kossyi1992.
 * The Kossyi parameterization is generalized by the addition of two optional terms,
 * the optional gas temperature exponent @f$ b_g @f$ (defaulting to 0) and the optional
 * temperature scale @f$ T_\mathrm{inv} @f$ @cite capitelli2000. The term
 * @f$ \exp(-T/T_\mathrm{inv}) @f$ is active only if a value is provided for
 * @f$ T_\mathrm{inv} @f$.
 *
 * @ingroup arrheniusGroup
 */
class TwoTempPlasmaRate : public ArrheniusBase
{
public:
    TwoTempPlasmaRate();
 
    //! Constructor.
    /*!
     *  @param A  Pre-exponential factor. The unit system is (kmol, m, s); actual units
     *      depend on the reaction order and the dimensionality (surface or bulk).
     *  @param b   Electron temperature exponent (non-dimensional).
     *  @param Ea  Activation energy in energy units [J/kmol]. Defaults to 0.
     *  @param EE  Activation electron energy in energy units [J/kmol]. Defaults to 0.
     *  @param bg  Optional. Gas temperature exponent (non-dimensional). Defaults to 0.
     *  @param Tinv Optional. Temperature scale for the term
     *      @f$ \exp(-T/T_\mathrm{inv}) @f$ [K]. If zero, this term is omitted.
     *      Defaults to 0.
     */
    TwoTempPlasmaRate(double A, double b, double Ea=0.0, double EE=0.0, double bg=0.0,
                      double Tinv=0.0);
 
    //! Constructor based on an AnyMap object instead of all parameters directly.
    TwoTempPlasmaRate(const AnyMap& node, const UnitStack& rate_units={});
 
    //! Set parameters from an AnyMap object.
    void setParameters(const AnyMap& node, const UnitStack& rate_units) override;
 
    //! Creates a new two-temperature-plasma reaction.
    unique_ptr<MultiRateBase> newMultiRate() const override {
        return make_unique<MultiRate<TwoTempPlasmaRate, TwoTempPlasmaData>>();
    }
 
    //! Returns the reaction type.
    const string type() const override {
        return "two-temperature-plasma";
    }
 
    //! Check that the reaction does not have the 'reversible: true' attribute.
    void setContext(const Reaction& rxn, const Kinetics& kin) override;
 
    //! Evaluates reaction rate.
    /*!
     *  @param shared_data  data shared by all reactions of a given type.
     */
    double evalFromStruct(const TwoTempPlasmaData& shared_data) const {
        // m_E4_R is the electron activation energy in temperature units.
        return m_A * std::exp(m_bg * shared_data.logT
                       + m_b * shared_data.logTe
                       - m_Ea_R * shared_data.recipT
                       + m_E4_R * (shared_data.electronTemp - shared_data.temperature)
                             * shared_data.recipTe * shared_data.recipT
                       - shared_data.temperature * m_recip_Tinv);
    }
 
    //! Evaluate derivative of reaction rate with respect to temperature
    //! divided by reaction rate.
    /*!
     *  This method does not consider changes of electron temperature.
     *  A corresponding warning is raised.
     *  @param shared_data  data shared by all reactions of a given type.
     */
    double ddTScaledFromStruct(const TwoTempPlasmaData& shared_data) const;
 
    //! Return the electron activation energy *Ea* [J/kmol].
    double activationElectronEnergy() const {
        return m_E4_R * GasConstant;
    }
 
protected:
    //! Get parameters.
    void getParameters(AnyMap& node) const override;
 
    //! Gas temperature exponent.
    double m_bg = 0.0;
 
    //! Reciprocate of the temperature scale for the optional term
    //! @f$ \exp(-T/T_\mathrm{inv}) @f$.
    /*!
     * A value of zero disables this term.
     */
    double m_recip_Tinv = 0.0;
};
 
}
 
#endif