CD_ItoKMCJSON.H

Go to the documentation of this file.

/* chombo-discharge
 * Copyright © 2023 SINTEF Energy Research.
 * Please refer to Copyright.txt and LICENSE in the chombo-discharge root directory.
 */
 
#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 FunctionEVX = std::function<Real(const Real E, const Real V, 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)>;
 
      ItoKMCJSON();
 
      virtual ~ItoKMCJSON() noexcept;
 
      virtual void
      parseRuntimeOptions() noexcept override;
 
      virtual Real
      computeDt(const RealVect a_E, const RealVect a_pos, const Vector<Real> a_densities) 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<FunctionEVX> 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;
 
      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
      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
      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<FunctionEVX, 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 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_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