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<ParticleSoA<ItoParticle>>&       a_secondaryParticles,
                      Vector<Real>&                           a_secondaryCDRFluxes,
                      Vector<ParticleSoA<Photon>>&            a_secondaryPhotons,
                      const Vector<ParticleSoA<ItoParticle>>& a_primaryParticles,
                      const Vector<Real>&                     a_primaryCDRFluxes,
                      const Vector<ParticleSoA<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<int>& a_distribution) const noexcept;
};
} // namespace ItoKMC
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif