PlasmaChannel1D.h

Go to the documentation of this file.

 
#ifndef RIZER_PLASMA_CHANNEL_1D_H
#define RIZER_PLASMA_CHANNEL_1D_H
 
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include "cantera/oneD/Domain1D.h"
#include "cantera/base/Solution.h"
#include "CollisionModel.h"
#include "PropertyTable.h"
#include "ReactorRHS.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace rizer {
 
// Physics + initial/boundary configuration for a PlasmaChannel1D.
struct PlasmaChannelConfig {
    std::string mech;               // Cantera mechanism (YAML) file path
    std::string phase;              // Phase name within `mech` (a PlasmaPhase
                                    // with "e-")
    std::size_t n_points = 1;       // Number of radial grid points [-]
                                    // (ignored if `grid` is given)
    double R_max = 1.0e-3;          // Outer (wall) radius R [m] (ignored if
                                    // `grid` is given)
    double rho = 0.1;               // Fixed mass density rho [kg/m^3]
                                    // (constant-volume model; not a state)
    double electric_field = 0.0;    // Constant applied electric field E
                                    // [V/m] (ignored if Et_t/Et_v given);
                                    // Python: `electric_field` (scalar case)
    double nu_E = 0.0;              // Elastic electron-heavy energy-exchange
                                    // frequency nu_E [1/s] (legacy closure
                                    // only; mutually exclusive with `specs`)
    double nu_m = 0.0;              // Electron momentum-transfer frequency
                                    // nu_m [1/s]. If > 0, @f$\sigma = n_e
                                    // e^2/(m_e \nu_m)@f$ (local, from the
                                    // evolving n_e) overrides the
                                    // @f$\sigma(T_e)@f$ table. (legacy
                                    // closure only; mutually exclusive with
                                    // `specs`)
    std::vector<double> nu_m_T, nu_m_v;  // Te-dependent @f$\nu_m(T_e)@f$
                                    // table [K],[1/s]; if given, overrides
                                    // the scalar nu_m (sigma then
                                    // self-regulates as Te rises, like the
                                    // 0D model). (legacy closure only;
                                    // mutually exclusive with `specs`)
    // Composition-resolved collision model (preferred over the legacy sigma/nu_m/
    // nu_E closures below -- mutually exclusive with them, see PlasmaChannel1D.cpp).
    // One entry per species, in species-index order; empty -> legacy closure.
    // molar_mass/is_electron are filled in by the constructor from the mechanism,
    // so callers only need to set energy_J/sigma_m2 (tabulated neutral), radius
    // (hard-sphere neutral), or Z (ion) per species -- see CollisionModel.h.
    // Python: built from the `mtcf` list of MomentumTransferCollisionFrequencyModel.
    std::vector<CollisionModel::SpeciesSpec> specs;
    double Te_min = 300.0;          // Collision-model Te grid lower bound [K]
                                    // (only used when `specs` is given)
    double Te_max = 1.0e5;          // Collision-model Te grid upper bound [K]
                                    // (only used when `specs` is given)
    std::size_t Te_n = 400;         // Collision-model Te grid point count [-]
                                    // (only used when `specs` is given)
    bool spitzer = true;            // Apply the Spitzer e-e correction
                                    // (II-13.18) [-] (only used when `specs`
                                    // is given)
    double D_species = 0.0;         // Constant scalar species mass
                                    // diffusivity D [m^2/s] (0 = frozen
                                    // species transport)
    bool reacting = true;           // Include finite-rate chemistry source terms [-]
    double T_amb = 300.0;           // Wall/ambient temperature T_amb [K];
                                    // also the outer-wall Dirichlet ghost
                                    // value for Tg
    std::vector<double> Y0;         // Initial + ambient mass fractions [-]
                                    // (length K, sums to 1); also the
                                    // outer-wall Dirichlet ghost value per
                                    // species
    // Explicit radial grid [m], increasing from 0. Empty -> setupUniformGrid
    // (n_points, R_max). When provided, it sets the mesh directly (Cantera-flame
    // style, Domain1D::setupGrid) and defines n_points and R_max.
    std::vector<double> grid;
    // Property tables (empty/constant -> disabled). Each `_T` array is the table's
    // temperature axis [K] (electron temperature Te for sigma/kappa_e, gas
    // temperature Tg for kappa); each `_v` array is the tabulated value at that
    // temperature, in the unit noted below.
    std::vector<double> sigma_T, sigma_v;       // Electrical conductivity
                                    // table @f$\sigma(T_e)@f$ [K],[S/m]
                                    // (legacy closure only; mutually
                                    // exclusive with `specs`)
    std::vector<double> kappa_T, kappa_v;       // Gas thermal conductivity
                                    // table @f$\kappa(T_g)@f$ [K],[W/m/K]
                                    // (empty = conduction on Tg disabled)
    std::vector<double> kappa_e_T, kappa_e_v;   // Electron thermal
                                    // conductivity table @f$\kappa_e(T_e)@f$
                                    // [K],[W/m/K] (empty = conduction on Te
                                    // disabled)
    // Initial radial temperature profiles (empty -> uniform T_amb-based):
    // `_r` is the radius axis [m], `_v` is the temperature at that radius [K].
    std::vector<double> initTg_r, initTg_v;     // Tg(r) at t=0 [m],[K];
                                    // Python: `Tg_profile`
    std::vector<double> initTe_r, initTe_v;     // Te(r) at t=0 [m],[K];
                                    // Python: `Te_profile`
    // Initial radial composition profile (empty -> uniform Y0 everywhere).
    // initY_r: radii [m] (length nr); initY_v: row-major [nr*K] mass fractions [-].
    std::vector<double> initY_r, initY_v;       // Python: `Y0_profile`
    // Field-vs-time table @f$E(t)@f$: Et_t [s], Et_v [V/m]. Empty -> constant
    // electric_field; non-empty -> E(t) interpolated, evaluated each time step.
    std::vector<double> Et_t, Et_v;             // Python: `electric_field`
                                    // (tuple/schedule case)
};
 
class PlasmaChannel1D : public Cantera::Domain1D {
public:
    explicit PlasmaChannel1D(const PlasmaChannelConfig& cfg);
 
    std::string domainType() const override { return "plasma-channel-1d"; }

    void eval(std::size_t jg, Cantera::span<const double> xg, Cantera::span<double> rg,
              Cantera::span<int> maskg, double rdt) override;

    std::string componentName(std::size_t n) const override;
    std::size_t componentIndex(const std::string& name,
                                bool checkAlias = true) const override;
    bool hasComponent(const std::string& name, bool checkAlias = true) const override;
    void getValues(const std::string& component,
                    Cantera::span<double> values) const override;

    double initialValue(std::size_t n, std::size_t j) override;
    void resetBadValues(Cantera::span<double> xg) override;

    void setElectricField(double electricField) { m_electric_field = electricField; }
    double electricField() const { return m_electric_field; }
    std::size_t nSpecies() const { return m_n_species; }

    double electronDensity(double Tg, double Te, const double* Y) const;
 
private:
    std::shared_ptr<Cantera::Solution> m_solution;  // Cantera thermo/kinetics
                                     // manager (PlasmaPhase)
    std::unique_ptr<ReactorRHS> m_reactor_rhs;  // Shared single-cell 2T
                                     // physics (chemistry/Joule/exchange)
    std::size_t m_n_species;      // Number of species K [-] (thermo->nSpecies())
    std::size_t m_electron_index; // Species index of "e-" [-] (npos if the
                                   // mechanism has none)
    double m_outer_radius;        // Outer (wall) radius R [m]
    double m_rho;                 // Fixed mass density rho [kg/m^3]
                                   // (constant-volume model)
    double m_electric_field;      // Applied electric field E [V/m], set per
                                   // eval() via setElectricField()
    double m_species_diffusivity; // Constant scalar species mass diffusivity
                                   // D [m^2/s] (0 = frozen)
    bool m_reacting;              // Include finite-rate chemistry source terms [-]
    double m_ambient_temperature; // Wall/ambient temperature T_amb [K]
    std::vector<double> m_Y0;     // Initial + ambient mass fractions [-]
                                   // (length K, sums to 1)
    PropertyTable m_kappa;        // Gas thermal conductivity table
                                   // @f$\kappa(T_g)@f$ [W/m/K]; empty ->
                                   // disabled
    PropertyTable m_kappa_e;      // Electron thermal conductivity table
                                   // @f$\kappa_e(T_e)@f$ [W/m/K]; empty ->
                                   // disabled
    PropertyTable m_initTg;       // Initial radial profile Tg(r) [K]; empty
                                   // -> uniform m_ambient_temperature
    PropertyTable m_initTe;       // Initial radial profile Te(r) [K]; empty
                                   // -> uniform m_ambient_temperature
    std::vector<PropertyTable> m_initY;  // Initial radial profiles Y_k(r)
                                     // [-], one per species (empty ->
                                     // uniform m_Y0)
    bool m_has_transport;         // True if any conduction/diffusion term is
                                   // enabled (kappa, kappa_e, or D_species > 0)
};
 
} // namespace rizer
 
#endif