CD_ItoKMCPhysics.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_ITOKMCPHYSICS_H
#define CD_ITOKMCPHYSICS_H
 
// Std includes
#include <memory>
#include <vector>
 
// Chombo includes
#include <RealVect.H>
#include <RefCountedPtr.H>
#include <List.H>
 
// Our includes
#include <CD_ItoSpecies.H>
#include <CD_CdrSpecies.H>
#include <CD_RtSpecies.H>
#include <CD_Photon.H>
#include <CD_ItoParticle.H>
#include <CD_PointParticle.H>
#include <CD_ItoKMCPhotoReaction.H>
#include <CD_ItoKMCSurfaceReactionSet.H>
#include <CD_KMCDualState.H>
#include <CD_KMCDualStateReaction.H>
#include <CD_KMCSolver.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace ItoKMC {
 
    using FPR = Real;
 
    using KMCState = KMCDualState<FPR>;
 
    using KMCReaction = KMCDualStateReaction<KMCState, FPR>;
 
    using KMCSolverType = KMCSolver<KMCReaction, KMCState, FPR>;
 
    using DiffusionFunction = std::function<RealVect(const ItoParticle& p, const Real& a_dt)>;
 
    enum SpeciesType
    {
      Ito, 
      CDR  
    };
 
    class ItoKMCPhysics
    {
    public:
      inline ItoKMCPhysics() noexcept;
 
      inline virtual ~ItoKMCPhysics() noexcept;
 
      inline void
      defineKMC() const noexcept;
 
      inline void
      killKMC() const noexcept;
 
      virtual Real
      getNeutralDensity(const RealVect& a_pos) const noexcept = 0;
 
      virtual Real
      computeAlpha(const Real a_E, const RealVect& a_x) const = 0;
 
      virtual Real
      computeEta(const Real a_E, const RealVect& a_x) const = 0;
 
      const Vector<RefCountedPtr<ItoSpecies>>&
      getItoSpecies() const;
 
      const Vector<RefCountedPtr<CdrSpecies>>&
      getCdrSpecies() const;
 
      const Vector<RefCountedPtr<RtSpecies>>&
      getRtSpecies() const;
 
      const Vector<DiffusionFunction>&
      getItoDiffusionFunctions() const noexcept;
 
      virtual Vector<std::string>
      getPlotVariableNames() const noexcept;
 
      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;
 
      virtual int
      getNumberOfPlotVariables() const noexcept;
 
      inline int
      getNumItoSpecies() const;
 
      inline int
      getNumCdrSpecies() const;
 
      inline int
      getNumPlasmaSpecies() const;
 
      inline int
      getNumPhotonSpecies() const;
 
      virtual bool
      needGradients() const noexcept;
 
      inline const std::map<int, std::pair<SpeciesType, int>>&
      getSpeciesMap() const noexcept;
 
      inline virtual void
      parseRuntimeOptions() noexcept;
 
      inline virtual Real
      initialSigma(const Real a_time, const RealVect& a_pos) const;
 
      virtual Vector<Real>
      computeMobilities(const Real a_time, const RealVect& a_pos, const RealVect& a_E) const noexcept = 0;
 
      virtual Vector<Real>
      computeDiffusionCoefficients(const Real a_time, const RealVect& a_pos, const RealVect& a_E) const noexcept = 0;
 
      virtual void
      secondaryEmissionEB(Vector<List<ItoParticle>>&       a_secondaryParticles,
                          Vector<Real>&                    a_cdrFluxes,
                          Vector<List<Photon>>&            a_secondaryPhotons,
                          const Vector<List<ItoParticle>>& a_primaryParticles,
                          const Vector<Real>&              a_cdrFluxesExtrap,
                          const Vector<List<Photon>>&      a_primaryPhotons,
                          const RealVect&                  a_E,
                          const RealVect&                  a_physicalCellCenter,
                          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 = 0;
 
      inline void
      advanceKMC(Vector<FPR>&            a_numParticles,
                 Vector<FPR>&            a_numNewPhotons,
                 Real&                   a_physicsDt,
                 const Vector<Real>&     a_phi,
                 const Vector<RealVect>& a_gradPhi,
                 const Real              a_dt,
                 const RealVect          a_E,
                 const RealVect          a_pos,
                 const Real              a_dx,
                 const Real              a_kappa) const;
 
      inline void
      reconcileParticles(Vector<List<ItoParticle>*>& a_particles,
                         const Vector<FPR>&          a_newNumParticles,
                         const Vector<FPR>&          a_oldNumParticles,
                         const RealVect              a_electricField,
                         const RealVect              a_cellPos,
                         const RealVect              a_centroidPos,
                         const RealVect              a_lo,
                         const RealVect              a_hi,
                         const RealVect              a_bndryCentroid,
                         const RealVect              a_bndryNormal,
                         const Real                  a_dx,
                         const Real                  a_kappa) const noexcept;
 
      inline void
      reconcilePhotons(Vector<List<Photon>*>& a_newPhotons,
                       const Vector<FPR>&     a_numNewPhotons,
                       const RealVect         a_cellPos,
                       const RealVect         a_centroidPos,
                       const RealVect         a_lo,
                       const RealVect         a_hi,
                       const RealVect         a_bndryCentroid,
                       const RealVect         a_bndryNormal,
                       const Real             a_dx,
                       const Real             a_kappa) const noexcept;
 
      inline void
      reconcilePhotoionization(Vector<List<ItoParticle>*>&   a_itoParticles,
                               Vector<List<PointParticle>*>& a_cdrParticles,
                               const Vector<List<Photon>*>&  a_absorbedPhotons) const noexcept;
 
    protected:
      enum class Algorithm
      {
        SSA,                 
        ExplicitEuler,       
        Midpoint,            
        PRC,                 
        ImplicitEuler,       
        HybridExplicitEuler, 
        HybridMidpoint,      
        HybridPRC,           
        HybridImplicitEuler  
      };
 
      enum class ParticlePlacement
      {
        Random,    
        Centroid,  
        Downstream 
      };
 
      Algorithm m_algorithm;
 
      ParticlePlacement m_particlePlacement;
 
      std::map<int, std::pair<SpeciesType, int>> m_speciesMap;
 
      std::string m_className;
 
      bool m_debug;
 
      bool m_isDefined;
 
      bool m_incrementNewParticles;
 
      static thread_local bool m_hasKMCSolver;
 
      static thread_local KMCSolverType m_kmcSolver;
 
      static thread_local KMCState m_kmcState;
 
      static thread_local std::vector<std::shared_ptr<const KMCReaction>> m_kmcReactionsThreadLocal;
 
      std::vector<KMCReaction> m_kmcReactions;
 
      std::vector<ItoKMCPhotoReaction> m_photoReactions;
 
      std::vector<Real> m_reactiveDtFactors;
 
      std::map<int, std::pair<std::discrete_distribution<int>, std::map<int, int>>> m_photoPathways;
 
      ItoKMCSurfaceReactionSet m_surfaceReactions;
 
      Vector<DiffusionFunction> m_itoDiffusionFunctions;
 
      Vector<RefCountedPtr<ItoSpecies>> m_itoSpecies;
 
      Vector<RefCountedPtr<CdrSpecies>> m_cdrSpecies;
 
      Vector<RefCountedPtr<RtSpecies>> m_rtSpecies;
 
      int m_downstreamSpecies;
 
      int m_maxNewParticles;
 
      int m_maxNewPhotons;
 
      int m_Ncrit;
 
      int m_NSSA;
 
      int m_maxIter;
 
      Real m_SSAlim;
 
      Real m_eps;
 
      Real m_exitTol;
 
      inline void
      define() noexcept;
 
      inline void
      defineSpeciesMap() noexcept;
 
      inline void
      definePhotoPathways() noexcept;
 
      inline void
      parsePPC() noexcept;
 
      inline void
      parseDebug() noexcept;
 
      inline void
      parseAlgorithm() 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 = 0;
 
      inline void
      removeParticles(List<ItoParticle>& a_particles, const long long a_numToRemove) const;
 
      inline bool
      computeUpstreamPosition(RealVect&                a_pos,
                              RealVect&                a_lo,
                              RealVect&                a_hi,
                              const int&               a_Z,
                              const List<ItoParticle>& a_particles,
                              const RealVect&          a_electricField,
                              const RealVect&          a_cellPos,
                              const Real&              a_dx) const noexcept;
 
      inline RealVect
      noDiffusion(const ItoParticle& a_particle, const Real a_dt) const noexcept;
 
      inline RealVect
      isotropicDiffusion(const ItoParticle& a_particle, const Real a_dt) const noexcept;
 
      inline RealVect
      forwardIsotropicDiffusion(const ItoParticle& a_particle, const Real a_dt) const noexcept;
    };
  } // namespace ItoKMC
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ItoKMCPhysicsImplem.H>
 
#endif