PlasmaCell.h

Go to the documentation of this file.

 
#ifndef RIZER_PLASMA_CELL_H
#define RIZER_PLASMA_CELL_H
 
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "cantera/base/Solution.h"
#include "cantera/base/ctexceptions.h"
#include "numeric/PropertyTable.h"
#include "numeric/TrialStateError.h"
#include "thermo/PlasmaState.h"
 
#include "cantera/thermo/PlasmaPhase.h"
#include "transport/CollisionModel.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace rizer
{
 
    // Exactly one of the two closures below is active per instance: if `collision`
    // is non-empty (i.e. CollisionModel::empty() is false) it is used exclusively
    // for sigma/nu_E and the sigma_T/sigma_v/nu_m_T/nu_m_v/nu_m/nu_E fallback
    // fields are ignored; otherwise the legacy tabulated/scalar closure is used.
    // See PlasmaCell::transport() in PlasmaCell.cpp for the selection logic.
    struct PlasmaCellConfig
    {
        bool reacting = true;
        CollisionModel collision;
        // Fallbacks used only when collision.empty():
        std::vector<double> sigma_T;
        std::vector<double> sigma_v;
        std::vector<double> nu_m_T;
        std::vector<double> nu_m_v;
        double nu_m = 0.0;
        double nu_E = 0.0;
        std::vector<double> species_h0k;
    };
 
    class PlasmaCell
    {
    public:
        struct Diagnostics
        {
            double P_elastic = 0.0;
            double P_inelastic = 0.0;
            double P_chemical_H = 0.0;
            double P_chemical_e = 0.0;
            double P_Joule = 0.0;
            double nu_eH = 0.0;
            double nu_ee = 0.0;
            double nu_eI = 0.0;
            double nu_eH_mass_weighted = 0.0;
        };

        PlasmaCell(std::shared_ptr<Cantera::Solution> sol, PlasmaCellConfig cfg);

        std::size_t nSpecies() const { return m_nsp; }
        std::size_t electronIndex() const { return m_ie; }
        const std::vector<double> &molecularWeights() const { return m_wt; }
        const std::shared_ptr<Cantera::Solution> &solution() const { return m_sol; }

        const std::vector<double> &speciesCp() const { return m_cp_mass; }

        std::string speciesName(std::size_t k) const;

        void sourceTerms(
            double Tg, double Te, const double *Y, double rho, double E, double &dTg,
            double &dTe, double *dY, double &lhs_Tg, double &lhs_Te,
            Diagnostics *diag = nullptr) const;

        double electricalConductivity(double Tg, double Te, const double *Y,
                                      double rho) const;
        double electronDensity(double Tg, double Te, const double *Y, double rho) const;

        void pressureAndElectronDensity(double Tg, double Te, const double *Y,
                                        double rho, double &p,
                                        double &electron_density) const;

        void updateSpeciesCp(double Tg, double Te, const double *Y,
                             double rho) const;

        void speciesEnthalpies(double Tg, double Te, const double *Y, double rho,
                               double *h) const;
 
    private:
        void fillSpeciesCp() const;

        TwoTemperatureState setState(double Tg, double Te, const double *Y,
                                     double rho) const;

        void transport(double Te, const TwoTemperatureState &state, double &sigma,
                       double &nu_E, double &nu_eH, double &nu_eI,
                       double &nu_eH_mass_weighted) const;

        std::shared_ptr<Cantera::Solution> m_sol;
        Cantera::PlasmaPhase *m_plasma = nullptr;
        std::size_t m_nsp;
        std::size_t m_ie;
        bool m_reacting;
        CollisionModel m_collision;
 
        PropertyTable m_sigma;               
        PropertyTable m_nu_m_tab;            
        double m_nu_m;                       
        double m_nu_E;                       
        std::vector<double> m_wt;            
        std::vector<char> m_is_electron_rxn; 
        std::vector<double> m_eps_th;
 
        mutable std::vector<double> m_Yc, m_wdot, m_uk, m_cpR, m_rop, m_X, m_nk;
        mutable std::vector<double> m_cp_mass;
    };
 
} // namespace rizer
 
#endif