CD_CdrPlasmaJSON.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2022-2026 SINTEF Energy Research
 * SPDX-FileCopyrightText: 2022-2026 NTNU
 * SPDX-FileCopyrightText: 2022-2026 Fanny Skirbekk
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_CDRPLASMAJSON_H
#define CD_CDRPLASMAJSON_H
 
// Std includes
#include <map>
#include <memory>
#include <string>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Our includes
#include <CD_CdrPlasmaPhysics.H>
#include <CD_NeutralSpeciesJSON.H>
#include <CD_CdrSpeciesJSON.H>
#include <CD_RteSpeciesJSON.H>
#include <CD_CdrPlasmaReactionJSON.H>
#include <CD_CdrPlasmaPhotoReactionJSON.H>
#include <CD_CdrPlasmaSurfaceReactionJSON.H>
#include <CD_LookupTable.H>
#include <CD_NamespaceHeader.H>
 
using json = nlohmann::json;
 
namespace Physics {
namespace CdrPlasma {
 
class CdrPlasmaJSON : public CdrPlasmaPhysics
{
public:
  using InitialDataFunction = std::function<Real(const RealVect a_position, const Real a_time)>;
 
  using FunctionEN = std::function<Real(const Real a_E, const Real a_N)>;
 
  using FunctionX = std::function<Real(const RealVect a_position)>;
 
  using FunctionEX = std::function<Real(const Real E, const RealVect x)>;
 
  using FunctionT = std::function<Real(const Real a_T)>;
 
  using FunctionTT = std::function<Real(const Real a_T1, const Real a_T2)>;
 
  CdrPlasmaJSON();
 
  CdrPlasmaJSON(const int a_dummy);
 
  virtual ~CdrPlasmaJSON();
 
  virtual void
  parseRuntimeOptions() override;
 
  virtual int
  getNumberOfPlotVariables() const override;
 
  virtual Vector<std::string>
  getPlotVariableNames() const override;
 
  virtual Vector<Real>
  getPlotVariables(const Vector<Real>&     a_cdrDensities,
                   const Vector<RealVect>& a_cdrGradients,
                   const Vector<Real>&     a_rteDensities,
                   const RealVect&         a_E,
                   const RealVect&         a_position,
                   const Real              a_dx,
                   const Real              a_dt,
                   const Real              a_time,
                   const Real              a_kappa) const override;
 
  virtual Real
  computeAlpha(const Real E, const RealVect& a_position) const override;
 
  virtual Real
  computeEta(const Real a_E, const RealVect& a_position) const override;
 
  virtual void
  advanceReactionNetwork(Vector<Real>&           a_cdrSources,
                         Vector<Real>&           a_rteSources,
                         const Vector<Real>&     a_cdrDensities,
                         const Vector<RealVect>& a_cdrGradients,
                         const Vector<Real>&     a_rteDensities,
                         const RealVect&         a_E,
                         const RealVect&         a_pos,
                         const Real              a_dx,
                         const Real              a_dt,
                         const Real              a_time,
                         const Real              a_kappa) const override;
 
  virtual Vector<RealVect>
  computeCdrDriftVelocities(const Real          a_time,
                            const RealVect&     a_pos,
                            const RealVect&     a_E,
                            const Vector<Real>& a_cdrDensities) const override;
 
  virtual Vector<Real>
  computeCdrDiffusionCoefficients(const Real          a_time,
                                  const RealVect&     a_pos,
                                  const RealVect&     a_E,
                                  const Vector<Real>& a_cdrDensities) const override;
 
  virtual Vector<Real>
  computeCdrElectrodeFluxes(const Real          a_time,
                            const RealVect&     a_pos,
                            const RealVect&     a_normal,
                            const RealVect&     a_E,
                            const Vector<Real>& a_cdrDensities,
                            const Vector<Real>& a_cdrVelocities,
                            const Vector<Real>& a_cdrGradients,
                            const Vector<Real>& a_rteFluxes,
                            const Vector<Real>& a_extrapCdrFluxes) const override;
 
  virtual Vector<Real>
  computeCdrDielectricFluxes(const Real          a_time,
                             const RealVect&     a_pos,
                             const RealVect&     a_normal,
                             const RealVect&     a_E,
                             const Vector<Real>& a_cdrDensities,
                             const Vector<Real>& a_cdrVelocities,
                             const Vector<Real>& a_cdrGradients,
                             const Vector<Real>& a_rteFluxes,
                             const Vector<Real>& a_extrapCdrFluxes) const override;
 
  virtual Vector<Real>
  computeCdrDomainFluxes(const Real           a_time,
                         const RealVect&      a_pos,
                         const int            a_dir,
                         const Side::LoHiSide a_side,
                         const RealVect&      a_E,
                         const Vector<Real>&  a_cdrDensities,
                         const Vector<Real>&  a_cdrVelocities,
                         const Vector<Real>&  a_cdrGradients,
                         const Vector<Real>&  a_rteFluxes,
                         const Vector<Real>&  a_extrapCdrFluxes) const override;
 
  virtual Real
  initialSigma(const Real a_time, const RealVect& a_pos) const override;
 
protected:
  enum class LookupMethod
  {
    Constant,
    FunctionX,
    FunctionT,
    FunctionTT,
    FunctionEN,
    FunctionEX,
    TableEN,
    TableEnergy,
    AlphaV,
    EtaV
  };
 
  enum class ReactionIntegrator
  {
    None,
    ExplicitEuler,
    ExplicitTrapezoidal,
    ExplicitMidpoint,
    ExplicitRK4
  };
 
  enum class ReactiveEnergyLoss
  {
    AddMean,
    SubtractMean,
    AddDirect,
    SubtractDirect,
    External
  };
 
  bool m_verbose;
 
  bool m_plotGas;
 
  bool m_plotAlpha;
 
  bool m_plotEta;
 
  bool m_discretePhotons;
 
  bool m_skipReactions;
 
  json m_json;
 
  ReactionIntegrator m_reactionIntegrator;
 
  std::string m_jsonFile;
 
  std::vector<json> m_cdrSpeciesJSON;
 
  std::vector<json> m_rteSpeciesJSON;
 
  std::function<Real(const RealVect a_position, const Real a_time)> m_initialSigma;
 
  FunctionX m_gasPressure;
 
  FunctionX m_gasTemperature;
 
  FunctionX m_gasDensity;
 
  Real m_chemistryDt;
 
  std::vector<FunctionX> m_neutralSpeciesDensities;
 
  std::vector<std::shared_ptr<NeutralSpeciesJSON>> m_neutralSpecies;
 
  std::map<std::string, int> m_neutralSpeciesMap;
 
  std::map<int, std::string> m_neutralSpeciesInverseMap;
 
  std::map<std::string, int> m_cdrSpeciesMap;
 
  std::map<int, std::string> m_cdrSpeciesInverseMap;
 
  std::map<int, bool> m_cdrIsEnergySolver;
 
  std::map<int, bool> m_cdrHasEnergySolver;
 
  std::map<int, std::tuple<Real, Real, Real>> m_cdrEnergyComputation;
 
  std::map<int, int> m_cdrTransportEnergyMap;
 
  std::map<int, Real> m_cdrMasses;
 
  std::map<std::string, int> m_rteSpeciesMap;
 
  std::map<int, std::string> m_rteSpeciesInverseMap;
 
  // =====================================================
  // TOWNSEND IONIZATION COEFFICIENT QUANTITIES BEGIN HERE
  // =====================================================
 
  LookupMethod m_alphaLookup;
 
  LookupMethod m_etaLookup;
 
  Real m_alphaConstant;
 
  Real m_etaConstant;
 
  FunctionEN m_alphaFunctionEN;
 
  FunctionEN m_etaFunctionEN;
 
  LookupTable1D<Real, 1> m_alphaTableEN;
 
  LookupTable1D<Real, 1> m_etaTableEN;
 
  // ================================
  // MOBILITY QUANTITIES BEGIN HERE
  // ================================
 
  std::map<int, LookupMethod> m_mobilityLookup;
 
  std::map<int, Real> m_mobilityConstants;
 
  std::map<int, FunctionEN> m_mobilityFunctionsEN;
 
  std::map<int, FunctionEX> m_mobilityFunctionsEX;
 
  std::map<int, LookupTable1D<Real, 1>> m_mobilityTablesEN;
 
  std::map<int, LookupTable1D<Real, 1>> m_mobilityTablesEnergy;
 
  // ================================
  // DIFFUSION  QUANTITIES BEGIN HERE
  // ================================
 
  std::map<int, LookupMethod> m_diffusionLookup;
 
  std::map<int, Real> m_diffusionConstants;
 
  std::map<int, FunctionEN> m_diffusionFunctionsEN;
 
  std::map<int, LookupTable1D<Real, 1>> m_diffusionTablesEN;
 
  std::map<int, LookupTable1D<Real, 1>> m_diffusionTablesEnergy;
 
  // ===========================================
  // PLASMA SPECIES TEMPERATURE DATA BEGINS HERE
  // ===========================================
 
  std::map<int, LookupMethod> m_temperatureLookup;
 
  std::map<int, FunctionX> m_temperatureConstants;
 
  std::map<int, LookupTable1D<Real, 1>> m_temperatureTablesEN;
 
  // ================================
  // REACTION DATA BEGINS HERE
  // ================================
 
  std::map<int, std::string> m_plasmaReactionDescriptions;
 
  std::map<int, LookupMethod> m_plasmaReactionLookup;
 
  std::map<int, Real> m_plasmaReactionConstants;
 
  std::map<int, int> m_plasmaReactionAlphaV;
 
  std::map<int, int> m_plasmaReactionEtaV;
  std::map<int, std::pair<int, FunctionT>> m_plasmaReactionFunctionsT;
 
  std::map<int, std::tuple<int, int, FunctionTT>> m_plasmaReactionFunctionsTT;
 
  std::map<int, FunctionEN> m_plasmaReactionFunctionsEN;
 
  std::map<int, LookupTable1D<Real, 1>> m_plasmaReactionTablesEN;
 
  std::map<int, std::pair<int, LookupTable1D<Real, 1>>> m_plasmaReactionTablesEnergy;
 
  std::map<int, FunctionEX> m_plasmaReactionEfficiencies;
 
  std::vector<CdrPlasmaReactionJSON> m_plasmaReactions;
 
  std::map<int, bool> m_plasmaReactionPlot;
 
  std::map<int, std::pair<bool, int>> m_plasmaReactionSolovievCorrection;
 
  std::map<int, std::map<int, std::pair<ReactiveEnergyLoss, Real>>> m_plasmaReactionEnergyLosses;
 
  std::map<int, bool> m_plasmaReactionHasEnergyLoss;
 
  // ================================
  // PHOTO-REACTIONS BEGIN HERE
  // ================================
 
  std::map<int, FunctionEX> m_photoReactionEfficiencies;
 
  std::map<int, bool> m_photoReactionUseHelmholtz;
 
  std::vector<CdrPlasmaPhotoReactionJSON> m_photoReactions;
 
  std::map<int, std::list<std::pair<int, Real>>> m_photoReactionEnergyLosses;
 
  std::map<int, bool> m_photoReactionHasEnergyLoss;
 
  // ===========================================
  // ELECTRODE SURFACE REACTIONS BEGIN HERE
  // ===========================================
 
  std::map<int, LookupMethod> m_electrodeReactionLookup;
 
  std::map<int, Real> m_electrodeReactionConstants;
 
  std::map<int, FunctionEX> m_electrodeReactionEfficiencies;
 
  std::vector<CdrPlasmaSurfaceReactionJSON> m_electrodeReactions;
 
  std::map<int, std::list<std::pair<int, Real>>> m_electrodeReactionEnergyLosses;
 
  std::map<int, bool> m_electrodeReactionHasEnergyLoss;
 
  std::map<int, bool> m_electrodeExtrapBC;
 
  // ===========================================
  // DIELECTRIC SURFACE REACTIONS BEGIN HERE
  // ===========================================
 
  std::map<int, LookupMethod> m_dielectricReactionLookup;
 
  std::map<int, Real> m_dielectricReactionConstants;
 
  std::map<int, FunctionEX> m_dielectricReactionEfficiencies;
 
  std::vector<CdrPlasmaSurfaceReactionJSON> m_dielectricReactions;
 
  std::map<int, std::list<std::pair<int, Real>>> m_dielectricReactionEnergyLosses;
 
  std::map<int, bool> m_dielectricReactionHasEnergyLoss;
 
  std::map<int, bool> m_dielectricExtrapBC;
 
  // ===========================================
  // DOMAIN SURFACE REACTIONS BEGIN HERE
  // ===========================================
 
  std::map<std::pair<int, Side::LoHiSide>, std::map<int, LookupMethod>> m_domainReactionLookup;
 
  std::map<std::pair<int, Side::LoHiSide>, std::map<int, Real>> m_domainReactionConstants;
 
  std::map<std::pair<int, Side::LoHiSide>, std::map<int, FunctionEX>> m_domainReactionEfficiencies;
 
  std::map<std::pair<int, Side::LoHiSide>, std::vector<CdrPlasmaSurfaceReactionJSON>> m_domainReactions;
 
  const std::map<char, int> m_dirCharToInt{{'x', 0}, {'y', 1}, {'z', 2}};
 
  const std::map<std::string, Side::LoHiSide> m_sideStringToSide{{"lo", Side::Lo}, {"hi", Side::Hi}};
 
  std::map<std::tuple<int, Side::LoHiSide, int>, bool> m_domainExtrapBC;
 
  // ===========================================
  // VARIOUS MEMBER FUNCTIONS BEGIN HERE
  // ===========================================
 
  virtual void
  parseOptions();
 
  virtual void
  parseIntegrator();
 
  virtual void
  parseJSON();
 
  virtual void
  initializeSigma();
 
  virtual void
  initializeNeutralSpecies();
 
  virtual void
  initializePlasmaSpecies();
 
  virtual void
  initializePhotonSpecies();
 
  virtual void
  parseMobilities();
 
  virtual void
  parseDiffusion();
 
  virtual void
  parseTemperatures();
 
  virtual void
  parseAlpha();
 
  virtual void
  parseEta();
 
  virtual void
  parsePlasmaReactions();
 
  virtual InitialDataFunction
  parsePlasmaSpeciesInitialData(const json& a_json) const;
 
  virtual ParticleSoA<NoPayload>
  parsePlasmaSpeciesInitialParticles(const json& a_json) const;
 
  virtual std::list<std::tuple<std::string, std::vector<std::string>, std::vector<std::string>>>
  parseReactionWildcards(const std::vector<std::string>& a_reactants,
                         const std::vector<std::string>& a_products,
                         const json&                     a_reaction);
  virtual void
  parseReactionString(std::vector<std::string>& a_reactants,
                      std::vector<std::string>& a_products,
                      const std::string&        a_reaction) const;
 
  virtual void
  sanctifyPlasmaReaction(const std::vector<std::string>& a_reactants,
                         const std::vector<std::string>& a_products,
                         const std::string&              a_reaction) const;
 
  virtual void
  getReactionSpecies(std::list<int>&                 a_plasmaReactants,
                     std::list<int>&                 a_neutralReactants,
                     std::list<int>&                 a_photonReactants,
                     std::list<int>&                 a_plasmaProducts,
                     std::list<int>&                 a_neutralProducts,
                     std::list<int>&                 a_photonProducts,
                     const std::vector<std::string>& a_reactants,
                     const std::vector<std::string>& a_products) const;
 
  virtual void
  parsePlasmaReactionRate(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parsePlasmaReactionScaling(const int a_index, const json& a_reactionJSON);
 
  virtual void
  parsePlasmaReactionPlot(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parsePlasmaReactionDescription(const int a_reactionIndex, const json& a_reactionJSON, const std::string& a_wildcard);
 
  virtual void
  parsePlasmaReactionSoloviev(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parsePlasmaReactionEnergyLosses(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parsePhotoReactions();
 
  virtual void
  parsePhotoReactionScaling(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parsePhotoReactionEnergyLosses(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  sanityCheckSpecies() const;
 
  virtual void
  sanctifyPhotoReaction(const std::vector<std::string>& a_reactants,
                        const std::vector<std::string>& a_products,
                        const std::string&              a_reaction) const;
 
  virtual void
  parseElectrodeReactions();
 
  virtual void
  parseElectrodeReactionRate(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseElectrodeReactionScaling(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseElectrodeReactionEnergyLosses(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseDielectricReactions();
 
  virtual void
  parseDielectricReactionRate(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseDielectricReactionScaling(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseDielectricReactionEnergyLosses(const int a_reactionIndex, const json& a_reactionJSON);
 
  virtual void
  parseDomainReactions();
 
  virtual void
  parseDomainReactionRate(const int                       a_reactionIndex,
                          const json&                     a_reactionJSON,
                          const std::vector<std::string>& a_sides);
 
  virtual void
  parseDomainReactionScaling(const int                       a_reactionIndex,
                             const json&                     a_reactionJSON,
                             const std::vector<std::string>& a_sides);
 
  virtual void
  sanctifySurfaceReaction(const std::vector<std::string>& a_reactants,
                          const std::vector<std::string>& a_products,
                          const std::string&              a_reaction) const;
 
  virtual std::vector<Real>
  computePlasmaSpeciesTemperatures(const RealVect&          a_position,
                                   const RealVect&          a_E,
                                   const std::vector<Real>& a_cdrDensities) const;
 
  virtual std::vector<Real>
  computePlasmaSpeciesEnergies(const RealVect&          a_position,
                               const RealVect&          a_E,
                               const std::vector<Real>& a_cdrDensities) const;
 
  virtual std::vector<Real>
  computePlasmaSpeciesMobilities(const RealVect&          a_position,
                                 const RealVect&          a_E,
                                 const std::vector<Real>& a_cdrDensities) const;
 
  virtual std::vector<Real>
  computePlasmaSpeciesDiffusion(const RealVect&          a_position,
                                const RealVect&          a_E,
                                const std::vector<Real>& a_cdrDensities) const;
 
  virtual Real
  computePlasmaReactionRate(const int&                   a_reactionIndex,
                            const std::vector<Real>&     a_cdrDensities,
                            const std::vector<Real>&     a_cdrMobilities,
                            const std::vector<Real>&     a_cdrDiffusionCoefficients,
                            const std::vector<Real>&     a_cdrTemperatures,
                            const std::vector<Real>&     a_cdrEnergies,
                            const std::vector<RealVect>& a_cdrGradients,
                            const RealVect&              a_pos,
                            const RealVect&              a_vectorE,
                            const Real&                  a_E,
                            const Real&                  a_Etd,
                            const Real&                  a_N,
                            const Real&                  a_alpha,
                            const Real&                  a_eta,
                            const Real&                  a_time) const;
 
  static void
  throwParserError(const std::string& a_error);
 
  static void
  throwParserWarning(const std::string& a_warning);
 
  static bool
  containsWildcard(const std::string& a_str);
 
  static bool
  containsBracket(const std::string& a_str);
 
  static bool
  isBracketed(const std::string& a_str);
 
  static std::string
  trim(const std::string& a_string);
 
  bool
  isNeutralSpecies(const std::string& a_name) const;
 
  bool
  isPlasmaSpecies(const std::string& a_name) const;
 
  bool
  isPhotonSpecies(const std::string& a_name) const;
 
  static bool
  doesFileExist(const std::string& a_filename);
 
  virtual void
  addPhotoIonization(std::vector<Real>&       a_cdrSources,
                     const std::vector<Real>& a_rteDensities,
                     const RealVect&          a_position,
                     const Real               a_E,
                     const Real               a_dt,
                     const Real               a_dx) const;
 
  virtual void
  integrateReactions(std::vector<Real>&           a_cdrDensities,
                     std::vector<Real>&           a_photonProduction,
                     const std::vector<RealVect>& a_cdrGradients,
                     const RealVect&              a_E,
                     const RealVect&              a_pos,
                     const Real                   a_dx,
                     const Real                   a_dt,
                     const Real                   a_time,
                     const Real                   a_kappa) const;
 
  void
  fillSourceTerms(std::vector<Real>&           a_cdrSources,
                  std::vector<Real>&           a_rteSources,
                  const std::vector<Real>&     a_cdrDensities,
                  const std::vector<RealVect>& a_cdrGradients,
                  const RealVect&              a_E,
                  const RealVect&              a_pos,
                  const Real                   a_dx,
                  const Real                   a_time,
                  const Real                   a_kappa) const;
 
  void
  integrateReactionsExplicitEuler(std::vector<Real>&           a_cdrDensities,
                                  std::vector<Real>&           a_photonProduction,
                                  const std::vector<RealVect>& a_cdrGradients,
                                  const RealVect&              a_E,
                                  const RealVect&              a_pos,
                                  const Real                   a_dx,
                                  const Real                   a_dt,
                                  const Real                   a_time,
                                  const Real                   a_kappa) const;
 
  void
  integrateReactionsImplicitEuler(std::vector<Real>&           a_cdrDensities,
                                  std::vector<Real>&           a_photonProduction,
                                  const std::vector<RealVect>& a_cdrGradients,
                                  const RealVect&              a_E,
                                  const RealVect&              a_pos,
                                  const Real                   a_dx,
                                  const Real                   a_dt,
                                  const Real                   a_time,
                                  const Real                   a_kappa) const;
 
  void
  integrateReactionsExplicitRK2(std::vector<Real>&           a_cdrDensities,
                                std::vector<Real>&           a_photonProduction,
                                const std::vector<RealVect>& a_cdrGradients,
                                const RealVect&              a_E,
                                const RealVect&              a_pos,
                                const Real                   a_dx,
                                const Real                   a_dt,
                                const Real                   a_time,
                                const Real                   a_kappa,
                                const Real                   a_tableuAlpha) const;
 
  void
  integrateReactionsExplicitRK4(std::vector<Real>&           a_cdrDensities,
                                std::vector<Real>&           a_photonProduction,
                                const std::vector<RealVect>& a_cdrGradients,
                                const RealVect&              a_E,
                                const RealVect&              a_pos,
                                const Real                   a_dx,
                                const Real                   a_dt,
                                const Real                   a_time,
                                const Real                   a_kappa) const;
};
} // namespace CdrPlasma
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif