PlasmaRates.h

Go to the documentation of this file.

// PlasmaRates.h
//
// C++ ports of the custom plasma reaction rates that rizer defines in
// Python as `ct.ExtensibleRate`s (rizer/kin/extensible_rate.py):
//
//   * janev-dissociative-recombination-C2Hy  — a closed-form rate in Te only.
//   * Druyvesteyn                             — modified Arrhenius in Te with
//        a squared-ratio exponential, k = A Te^b exp(-(Ea/Te)^2).
//   * reverse-two-temperature-plasma          — the reverse of a forward
//        `two-temperature-plasma` reaction, k_rev = k_fwd / K_eq.
//
// Python `ct.ExtensibleRate`s are unknown to Cantera's C++ ReactionRateFactory,
// so a mechanism that uses them (e.g. data/mechanisms/Goutier2025/CH4_to_C2H2.yaml)
// fails to load in C++. Registering these C++ rates via `registerPlasmaRates()`
// before `newSolution()` lets that mechanism load and evaluate natively in the
// PlasmaChannel1D extension.
 
#ifndef RIZER_PLASMARATES_H
#define RIZER_PLASMARATES_H
 
#include "cantera/kinetics/ReactionData.h"
#include "cantera/kinetics/ReactionRate.h"
#include "cantera/base/AnyMap.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace Cantera { class Solution; }
 
namespace rizer {

void registerPlasmaRates();

std::shared_ptr<Cantera::Solution> loadMechanism(const std::string& mech,
                                                 const std::string& phase);
 
 
// ---------------------------------------------------------------------------
//  janev-dissociative-recombination-C2Hy
// ---------------------------------------------------------------------------

struct ElectronTemperatureData : public Cantera::ReactionData
{
    bool update(const Cantera::ThermoPhase& phase,
                const Cantera::Kinetics& kin) override;
    using Cantera::ReactionData::update;
    void invalidateCache() override {
        Cantera::ReactionData::invalidateCache();
        electronTemp = NAN;
    }
    double electronTemp = 1.0; 
};

class JanevDissociativeRecombinationC2HyRate : public Cantera::ReactionRate
{
public:
    JanevDissociativeRecombinationC2HyRate() = default;

    JanevDissociativeRecombinationC2HyRate(const Cantera::AnyMap& node,
                                            const Cantera::UnitStack& rate_units);
 
    std::unique_ptr<Cantera::MultiRateBase> newMultiRate() const override;
 
    const std::string type() const override {
        return "janev-dissociative-recombination-C2Hy";
    }

    void setParameters(const Cantera::AnyMap& node,
                        const Cantera::UnitStack& rate_units) override;

    double evalFromStruct(const ElectronTemperatureData& shared_data) const;
 
protected:
    void getParameters(Cantera::AnyMap& node) const override;
 
    double m_A = NAN; 
};
 
 
// ---------------------------------------------------------------------------
//  Druyvesteyn
// ---------------------------------------------------------------------------

class DruyvesteynRate : public Cantera::ReactionRate
{
public:
    DruyvesteynRate() = default;

    DruyvesteynRate(const Cantera::AnyMap& node,
                     const Cantera::UnitStack& rate_units);
 
    std::unique_ptr<Cantera::MultiRateBase> newMultiRate() const override;
 
    const std::string type() const override { return "Druyvesteyn"; }

    void setParameters(const Cantera::AnyMap& node,
                        const Cantera::UnitStack& rate_units) override;

    void validate(const std::string& equation,
                   const Cantera::Kinetics& kin) override;

    double evalFromStruct(const ElectronTemperatureData& shared_data) const;

    double logRate(double Te) const;
 
protected:
    void getParameters(Cantera::AnyMap& node) const override;
 
    double m_A = NAN;    
    double m_b = NAN;    
    double m_Ea_K = NAN; 
};
 
 
// ---------------------------------------------------------------------------
//  reverse-two-temperature-plasma
// ---------------------------------------------------------------------------

struct ReverseTwoTempData : public Cantera::ReactionData
{
    bool update(const Cantera::ThermoPhase& phase,
                const Cantera::Kinetics& kin) override;
    using Cantera::ReactionData::update;
    void invalidateCache() override {
        Cantera::ReactionData::invalidateCache();
        m_Tg = m_Te = m_P = NAN;
    }

    void buildShadow(const Cantera::ThermoPhase& phase,
                      const Cantera::Kinetics& kin);

    std::shared_ptr<Cantera::Solution> shadow;
    std::vector<double> kf_Tg, Keq_Tg;
    std::vector<double> kf_Te, Keq_Te;
    std::vector<double> logKeq_Tg, logKeq_Te;
    std::unordered_map<std::string, size_t> fwdIndex;
    std::unordered_set<std::string> ambiguousForward;
    bool anyTeTagged = false;
    std::vector<std::shared_ptr<Cantera::ReactionRate>> fwdRate;
    std::vector<double> deltaN;

    double gasTemperature() const { return m_Tg; }
    double electronTemperature() const { return m_Te; }
 
private:
    void computeLogEquilibriumConstants(std::vector<double>& logKeq);
 
    double m_Tg = NAN; 
    double m_Te = NAN; 
    double m_P = NAN;  
    std::vector<double> m_deltaG; 
};

class ReverseTwoTemperaturePlasmaRate : public Cantera::ReactionRate
{
public:
    ReverseTwoTemperaturePlasmaRate() = default;

    ReverseTwoTemperaturePlasmaRate(const Cantera::AnyMap& node,
                                     const Cantera::UnitStack& rate_units);
 
    std::unique_ptr<Cantera::MultiRateBase> newMultiRate() const override;
 
    const std::string type() const override {
        return "reverse-two-temperature-plasma";
    }

    void setParameters(const Cantera::AnyMap& node,
                        const Cantera::UnitStack& rate_units) override;

    double evalFromStruct(const ReverseTwoTempData& shared_data) const;
 
protected:
    void getParameters(Cantera::AnyMap& node) const override;

    std::string m_forward_equation;
    std::string m_T = "Tg";
    mutable size_t m_idx = Cantera::npos;
};
 
} // namespace rizer
 
#endif // RIZER_PLASMARATES_H