ElectronReactions.cpp

Go to the documentation of this file.

#include "kinetics/ElectronReactions.h"
 
#include "cantera/kinetics/Kinetics.h"
#include "cantera/kinetics/Reaction.h"
 
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace rizer
{
 
    // ------------------------------------------------------------------------------ //
    //   Free functions                                                               //
    // ------------------------------------------------------------------------------ //
 
    bool equationHasElectron(const std::string &equation,
                             const std::string &electron)
    {
        std::string s = equation;
        for (char &ch : s)
        {
            if (ch == '+' || ch == '=' || ch == '<' || ch == '>')
                ch = ' ';
        }
        std::istringstream iss(s);
        std::string token;
        while (iss >> token)
        {
            if (token == electron)
                return true;
        }
        return false;
    }
 
    ElectronReactionIndex buildElectronReactionIndex(
        Cantera::Kinetics &kinetics, const std::string &electron,
        const std::vector<double> &species_h0k, std::size_t n_species,
        bool reacting)
    {
        const std::size_t n_reactions = kinetics.nReactions();
        ElectronReactionIndex index;
        index.is_electron_reaction.assign(n_reactions, 0);
        index.threshold_energy.assign(n_reactions, 0.0);
 
        // Selected exactly as the Python reference selects them: the electron
        // participates iff it appears in the equation. That covers
        // two-temperature-plasma, three-body-two-temperature-plasma,
        // reverse-two-temperature-plasma, Druyvesteyn and janev-* reactions,
        // including the ones carrying a spectator electron.
        for (std::size_t i = 0; i < n_reactions; i++)
        {
            if (equationHasElectron(kinetics.reaction(i)->equation(), electron))
            {
                index.is_electron_reaction[i] = 1;
                index.any_electron_reaction = true;
            }
        }
 
        if (!(reacting && index.any_electron_reaction))
        {
            return index;
        }
 
        // Fixed per-reaction threshold energy, eps_th_i = sum_k nu_ki H_k(0 K),
        // from the caller's per-species formation enthalpies. Mirrors
        // rizer.kinetics.electron_reactions.ElectronicReactionEnergetics.
        if (species_h0k.empty())
        {
            throw std::invalid_argument(
                "buildElectronReactionIndex: species_h0k is required (the "
                "mechanism has an electron-impact reaction and chemistry is "
                "live).");
        }
        if (species_h0k.size() != n_species)
        {
            throw std::invalid_argument(
                "buildElectronReactionIndex: species_h0k has " +
                std::to_string(species_h0k.size()) + " entries, expected " +
                std::to_string(n_species) + ".");
        }
        kinetics.getReactionDelta(
            Cantera::span<const double>(species_h0k.data(), n_species),
            Cantera::span<double>(index.threshold_energy.data(),
                                  index.threshold_energy.size()));
        return index;
    }
 
} // namespace rizer