CD_ItoKMCJSON.H

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2021-2026 SINTEF Energy Research
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */
 
#ifndef CD_ITOKMCJSON_H
#define CD_ITOKMCJSON_H
 
// Std includes
#include <map>
#include <memory>
#include <string>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Our includes
#include <CD_ItoKMCBackgroundSpecies.H>
#include <CD_ItoKMCPhysics.H>
#include <CD_LookupTable.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace ItoKMC {
 
    class ItoKMCJSON : public ItoKMCPhysics
    {
    public:
      using FunctionXt = 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 FunctionEVXTP = std::function<
        Real(const Real E, const Real V, const Real dx, const Real dt, const RealVect& x, const Vector<Real>& phi)>;
 
      using FunctionDXP = std::function<Real(const Real dx, const Vector<Real>& phi)>;
 
      using FunctionT = std::function<Real(const Real a_T)>;
 
      using FunctionTT = std::function<Real(const Real a_T1, const Real a_T2)>;
 
      ItoKMCJSON();
 
      virtual ~ItoKMCJSON() noexcept;
 
      virtual void
      parseRuntimeOptions() noexcept override;
 
      virtual Real
      getNeutralDensity(const RealVect& a_pos) const noexcept override;
 
      virtual Real
      computeAlpha(const Real a_E, const RealVect& a_pos) const noexcept override;
 
      virtual Real
      computeEta(const Real a_E, const RealVect& a_pos) const noexcept override;
 
      virtual Vector<std::string>
      getPlotVariableNames() const noexcept override;
 
      virtual Vector<Real>
      getPlotVariables(const RealVect&         a_E,
                       const RealVect&         a_pos,
                       const Vector<Real>&     a_phi,
                       const Vector<RealVect>& a_gradPhi,
                       const Real              a_dx,
                       const Real              a_kappa) const noexcept override;
 
      virtual int
      getNumberOfPlotVariables() const noexcept override;
 
      virtual bool
      needGradients() const noexcept override;
 
      virtual Vector<Real>
      computeMobilities(const Real a_time, const RealVect& a_pos, const RealVect& a_E) const noexcept override;
 
      virtual Vector<Real>
      computeDiffusionCoefficients(const Real      a_time,
                                   const RealVect& a_pos,
                                   const RealVect& a_E) const noexcept override;
 
      virtual void
      secondaryEmissionEB(Vector<List<ItoParticle>>&       a_secondaryParticles,
                          Vector<Real>&                    a_secondaryCDRFluxes,
                          Vector<List<Photon>>&            a_secondaryPhotons,
                          const Vector<List<ItoParticle>>& a_primaryParticles,
                          const Vector<Real>&              a_primaryCDRFluxes,
                          const Vector<List<Photon>>&      a_primaryPhotons,
                          const RealVect&                  a_E,
                          const RealVect&                  a_cellCenter,
                          const RealVect&                  a_cellCentroid,
                          const RealVect&                  a_bndryCentroid,
                          const RealVect&                  a_bndryNormal,
                          const Real                       a_bndryArea,
                          const Real                       a_dx,
                          const Real                       a_dt,
                          const bool                       a_isDielectric,
                          const int                        a_matIndex) const noexcept override;
 
    protected:
      bool m_verbose;
 
      bool m_plotGas;
 
      bool m_plotAlpha;
 
      bool m_plotEta;
 
      bool m_skipReactions;
 
      bool m_previewRates;
 
      int m_numPlasmaSpecies;
 
      int m_numPhotonSpecies;
 
      nlohmann::json m_json;
 
      std::string m_jsonFile;
 
      std::set<std::string> m_allSpecies;
 
      std::map<std::string, int> m_backgroundSpeciesMap;
 
      std::map<int, std::string> m_backgroundSpeciesMapInverse;
 
      std::vector<ItoKMCBackgroundSpecies> m_backgroundSpecies;
 
      std::vector<bool> m_backgroundSpeciesPlot;
 
      std::map<std::string, SpeciesType> m_plasmaSpeciesTypes;
 
      std::map<std::string, int> m_itoSpeciesMap;
 
      std::map<std::string, int> m_cdrSpeciesMap;
 
      std::map<std::string, int> m_plasmaIndexMap;
 
      std::map<std::string, int> m_photonIndexMap;
 
      std::vector<FunctionEX> m_mobilityFunctions;
 
      std::vector<FunctionEX> m_diffusionCoefficients;
 
      std::vector<FunctionEX> m_plasmaTemperatures;
 
      std::vector<FunctionEVXTP> m_kmcReactionRates;
 
      std::vector<FunctionEX> m_fluidRates;
 
      std::vector<std::list<size_t>> m_plasmaReactionBackgroundReactants;
 
      std::vector<std::list<size_t>> m_plasmaReactionPlasmaReactants;
 
      std::vector<std::list<size_t>> m_plasmaReactionPlasmaProducts;
 
      std::vector<std::list<size_t>> m_plasmaReactionPhotonProducts;
 
      std::vector<std::pair<bool, std::string>> m_kmcReactionGradientCorrections;
 
      std::vector<std::pair<bool, std::string>> m_kmcReactionRatePlots;
 
      std::map<int, std::pair<bool, int>> m_plasmaReactionSolovievCorrection;
 
      std::pair<bool, std::string> m_autoAlpha;
 
      std::pair<bool, std::string> m_autoEta;
 
      std::vector<std::pair<int, FunctionEN>> m_dielectricFieldEmission;
 
      std::vector<std::pair<int, FunctionEN>> m_electrodeFieldEmission;
 
      FunctionEX m_alpha;
 
      FunctionEX m_eta;
 
      FunctionX m_gasPressure;
 
      FunctionX m_gasTemperature;
 
      FunctionX m_gasNumberDensity;
 
      virtual std::string
      trim(const std::string& a_string) const noexcept;
 
      virtual void
      parseJSON();
 
      virtual void
      parseVerbose() noexcept;
 
      virtual void
      throwParserError(const std::string& a_error) const noexcept;
 
      virtual void
      throwParserWarning(const std::string& a_warning) const noexcept;
 
      virtual bool
      doesFileExist(const std::string& a_filename) const noexcept;
 
      virtual bool
      isBackgroundSpecies(const std::string& a_name) const noexcept;
 
      virtual bool
      isPlasmaSpecies(const std::string& a_name) const noexcept;
 
      virtual bool
      isPhotonSpecies(const std::string& a_name) const noexcept;
 
      virtual bool
      containsWildcard(const std::string& a_str) const noexcept;
 
      virtual bool
      containsBracket(const std::string& a_str) const noexcept;
 
      virtual bool
      isBracketed(const std::string& a_str) const noexcept;
 
      virtual void
      checkMolarFraction(const RealVect& a_position) const noexcept;
 
      virtual void
      sanctifyPlasmaReaction(const std::vector<std::string>& a_reactants,
                             const std::vector<std::string>& a_products,
                             const std::string&              a_reaction) const noexcept;
 
      virtual void
      sanctifyPhotoReaction(const std::vector<std::string>& a_reactants,
                            const std::vector<std::string>& a_products,
                            const std::string&              a_reaction) const noexcept;
 
      virtual void
      initializeGasLaw();
 
      virtual void
      initializeBackgroundSpecies();
 
      virtual void
      initializeTownsendCoefficient(const std::string& a_coeff);
 
      virtual void
      initializeAutomaticTownsend(const std::string& a_coeff);
 
      virtual void
      previewFunctionEX(const nlohmann::json& a_json, const FunctionEX& a_function) const;
 
      virtual void
      printFluidRates() const noexcept;
 
      virtual void
      initializePlasmaSpecies();
 
      virtual void
      initializeParticles();
 
      virtual void
      initializeDensities();
 
      virtual void
      initializeMobilities();
 
      virtual void
      initializeDiffusionCoefficients();
 
      virtual void
      initializeTemperatures();
 
      virtual void
      initializePhotonSpecies();
 
      virtual void
      initializePlasmaReactions();
 
      virtual void
      initializePhotoReactions();
 
      virtual void
      initializeSurfaceEmission(const std::string& a_surface);
 
      virtual void
      initializeFieldEmission();
 
      virtual void
      initializeParticlePlacement();
 
      virtual void
      parseReactionString(std::vector<std::string>& a_reactants,
                          std::vector<std::string>& a_products,
                          const std::string&        a_reaction) const noexcept;
 
      virtual void
      getReactionSpecies(std::list<size_t>&              a_backgroundReactants,
                         std::list<size_t>&              a_plasmaReactants,
                         std::list<size_t>&              a_photonReactants,
                         std::list<size_t>&              a_backgroundProducts,
                         std::list<size_t>&              a_plasmaProducts,
                         std::list<size_t>&              a_photonProducts,
                         const std::vector<std::string>& a_reactants,
                         const std::vector<std::string>& a_products) const noexcept;
 
      virtual std::pair<FunctionEVXTP, FunctionEX>
      parsePlasmaReactionRate(const nlohmann::json&    a_reactionJSON,
                              const std::list<size_t>& a_backgroundReactants,
                              const std::list<size_t>& a_plasmaReactants) const;
 
      virtual std::pair<bool, std::string>
      parsePlasmaReactionPlot(const nlohmann::json& a_reactionJSON) const;
 
      virtual std::pair<bool, std::string>
      parsePlasmaReactionGradientCorrection(const nlohmann::json& a_reactionJSON) const;
 
      virtual Real
      parsePlasmaReactionDt(const nlohmann::json& a_reactionJSON) const;
 
      virtual LookupTable1D<Real, 1>
      parseTableEByN(const nlohmann::json& a_tableEntry, const std::string& a_dataID) const;
 
      virtual std::vector<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 nlohmann::json&           a_reactionJSON) const noexcept;
 
      virtual void
      updateReactionRates(std::vector<std::shared_ptr<const KMCReaction>>& a_kmcReactions,
                          const RealVect                                   a_E,
                          const RealVect                                   a_pos,
                          const Vector<Real>&                              a_phi,
                          const Vector<RealVect>&                          a_gradPhi,
                          const Real                                       a_dt,
                          const Real                                       a_dx,
                          const Real                                       a_kappa) const noexcept override;
 
      std::vector<size_t>
      multinomial(const size_t N, const std::discrete_distribution<size_t>& a_distribution) const noexcept;
    };
  } // namespace ItoKMC
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif