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 List<PointParticle>
      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