CD_ItoKMCStepper.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_ITOKMCSTEPPER_H
#define CD_ITOKMCSTEPPER_H
 
// Std includes
#include <functional>
#include <optional>
 
// Our includes
#include <CD_TimeStepper.H>
#include <CD_ItoKMCPhysics.H>
#include <CD_ItoLayout.H>
#include <CD_CdrLayout.H>
#include <CD_ParticleContainer.H>
#include <CD_ParticleManagement.H>
#include <CD_RtLayout.H>
#include <CD_McPhoto.H>
#include <CD_FieldSolver.H>
#include <CD_ItoSolver.H>
#include <CD_CdrCTU.H>
#include <CD_FieldSolverGMG.H>
#include <CD_SurfaceODESolver.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
namespace ItoKMC {
 
enum class SpeciesSubset
{
  All,                       
  AllMobile,                 
  AllDiffusive,              
  AllMobileOrDiffusive,      
  AllMobileAndDiffusive,     
  Charged,                   
  ChargedMobile,             
  ChargedDiffusive,          
  ChargedMobileOrDiffusive,  
  ChargedMobileAndDiffusive, 
  Stationary,                
};
 
template <typename I = ItoSolver, typename C = CdrCTU, typename R = McPhoto, typename F = FieldSolverGMG>
class ItoKMCStepper : public TimeStepper
{
public:
  static_assert(std::is_base_of<ItoSolver, I>::value, "I must derive from ItoSolver");
  static_assert(std::is_base_of<CdrSolver, C>::value, "C must derive from CdrSolver");
  static_assert(std::is_base_of<McPhoto, R>::value, "R must derive from McPhoto");
  static_assert(std::is_base_of<FieldSolver, FieldSolverGMG>::value, "F must derive from FieldSolver");
 
  ItoKMCStepper() noexcept;
 
  ItoKMCStepper(RefCountedPtr<ItoKMCPhysics>& a_physics) noexcept;
 
  virtual ~ItoKMCStepper() noexcept;
 
  virtual void
  parseOptions() noexcept;
 
  virtual void
  parseRuntimeOptions() noexcept override;
 
  virtual void
  allocate() noexcept override;
 
  virtual void
  setupSolvers() noexcept override;
 
  virtual void
  initialData() noexcept override;
 
  virtual void
  postCheckpointSetup() noexcept override;
 
  virtual void
  postInitialize() noexcept override;
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckpointHeader(HDF5HeaderData& a_header) const noexcept override;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointHeader(HDF5HeaderData& a_header) noexcept override;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckpointData(HDF5Handle& a_handle, const int a_lvl) const noexcept override;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointData(HDF5Handle& a_handle, const int a_lvl) noexcept override;
#endif
 
  virtual int
  getNumberOfPlotVariables() const noexcept override;
 
  virtual Vector<std::string>
  getPlotVariableNames() const noexcept override;
 
  virtual void
  writePlotData(LevelData<EBCellFAB>& a_output,
                int&                  a_icomp,
                const std::string&    a_outputRealm,
                const int             a_level) const noexcept override;
 
  virtual Vector<long int>
  getCheckpointLoads(const std::string& a_realm, const int a_level) const override;
 
  virtual Real
  advance(const Real a_dt) override = 0;
 
  virtual Real
  computeDt() override;
 
  virtual void
  synchronizeSolverTimes(const int a_step, const Real a_time, const Real a_dt) noexcept override;
 
  virtual void
  printStepReport() noexcept override;
 
  virtual void
  registerRealms() noexcept override;
 
  virtual void
  registerOperators() noexcept override;
 
  virtual void
  prePlot() noexcept override;
 
  virtual void
  postPlot() noexcept override;
 
  virtual void
  preRegrid(const int a_lmin, const int a_oldFinestLevel) noexcept override;
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) noexcept override;
 
  virtual void
  postRegrid() noexcept override;
 
  virtual bool
  loadBalanceThisRealm(const std::string& a_realm) const override;
 
  virtual void
  loadBalanceBoxes(Vector<Vector<int>>&             a_procs,
                   Vector<Vector<Box>>&             a_boxes,
                   const std::string&               a_realm,
                   const Vector<DisjointBoxLayout>& a_grids,
                   const int                        a_lmin,
                   const int                        a_finestLevel) override;
 
  virtual void
  setVoltage(const std::function<Real(const Real a_time)>& a_voltage) noexcept;
 
  virtual Real
  getTime() const noexcept;
 
  virtual void
  computeElectricField(EBAMRCellData& a_electricField, const phase::which_phase a_phase) const noexcept;
 
protected:
  enum class TimeCode
  {
    AdvectionIto,
    DiffusionIto,
    AdvectionDiffusionIto,
    AdvectionDiffusionCDR,
    RelaxationTime,
    Hardcap,
    Physics
  };
 
  enum class CdrProductInjection
  {
    Mesh,
 
    Particle
  };
 
  BoxSorting m_boxSort;
 
  TimeCode m_timeCode;
 
  std::string m_fluidRealm;
 
  std::string m_particleRealm;
 
  std::string m_name;
 
  phase::which_phase m_plasmaPhase;
 
  RefCountedPtr<ItoKMCPhysics> m_physics;
 
  RefCountedPtr<ItoLayout<ItoSolver>> m_ito;
 
  RefCountedPtr<CdrLayout<CdrSolver>> m_cdr;
 
  RefCountedPtr<RtLayout<McPhoto>> m_rte;
 
  RefCountedPtr<FieldSolver> m_fieldSolver;
 
  RefCountedPtr<SurfaceODESolver<1>> m_sigmaSolver;
 
  Vector<RefCountedPtr<ParticleContainer<ItoParticle>>> m_secondaryParticles;
 
  Vector<RefCountedPtr<ParticleContainer<Photon>>> m_secondaryPhotons;
 
  Vector<EBAMRIVData> m_cdrFluxes;
 
  Vector<EBAMRIVData> m_cdrFluxesExtrap;
 
  std::function<Real(const Real a_time)> m_voltage;
 
  bool m_abortOnFailure;
 
  bool m_redistributeCDR;
 
  CdrProductInjection m_cdrProductInjection;
 
  bool m_dualGrid;
 
  bool m_profile;
 
  bool m_loadBalanceParticles;
 
  bool m_loadBalanceFluid;
 
  bool m_plotConductivity;
 
  bool m_plotCurrentDensity;
 
  bool m_plotParticlesPerPatch;
 
  int m_mergeInterval;
 
  Real m_maxReducedField;
 
  Real m_prevDt;
 
  Real m_maxGrowthDt;
 
  Real m_maxShrinkDt;
 
  Real m_loadPerCell;
 
  Real m_toleranceEB;
 
  Real m_minParticleAdvectionCFL;
 
  Real m_maxParticleAdvectionCFL;
 
  Real m_minParticleDiffusionCFL;
 
  Real m_maxParticleDiffusionCFL;
 
  Real m_minParticleAdvectionDiffusionCFL;
 
  Real m_maxParticleAdvectionDiffusionCFL;
 
  Real m_fluidAdvectionDiffusionCFL;
 
  Real m_relaxTimeFactor;
 
  Real m_minDt;
 
  Real m_maxDt;
 
  Real m_particleAdvectionDt;
 
  Real m_particleDiffusionDt;
 
  Real m_particleAdvectionDiffusionDt;
 
  Real m_fluidAdvectionDiffusionDt;
 
  Real m_relaxationTime;
 
  Real m_physicsDt;
 
  Real m_physicsDtFactor;
 
  Vector<EBAMRCellData> m_loadBalancePPC;
 
  Vector<EBAMRCellData> m_cdrMobilities;
 
  Vector<EBAMRCellData> m_fluidGradPhiCDR;
 
  Vector<EBAMRCellData> m_fluidGradPhiIto;
 
  Vector<EBAMRCellData> m_fluidPhiIto;
 
  mutable Vector<RefCountedPtr<ParticleContainer<NoPayload>>> m_cdrProducts;
 
  EBAMRCellData m_particleCdrProduction;
 
  Vector<int> m_loadBalanceIndices;
 
  EBAMRCellData m_currentDensity;
 
  EBAMRCellData m_physicsPlotVariables;
 
  EBAMRCellData m_neutralDensity;
 
  EBAMRCellData m_conductivityCell;
 
  EBAMRFluxData m_conductivityFace;
 
  EBAMRIVData m_conductivityEB;
 
  EBAMRCellData m_particleItoPPC;
 
  EBAMRCellData m_particleYPC;
 
  EBAMRCellData m_particleEPS;
 
  EBAMRCellData m_particleOldItoPPC;
 
  EBAMRCellData m_fluidCdrPPC;
 
  EBAMRCellData m_fluidOldCdrPPC;
 
  EBAMRCellData m_fluidPPC;
 
  EBAMRCellData m_fluidYPC;
 
  EBAMRCellData m_electricFieldFluid;
 
  EBAMRCellData m_electricFieldParticle;
 
  EBAMRCellData m_kmcDt;
 
  Vector<EBAMRCellData> m_energySources;
 
  EBAMRCellData m_EdotJ;
 
  mutable EBAMRCellData m_fluidScratch1;
 
  mutable EBAMRCellData m_fluidScratchD;
 
  mutable EBAMRCellData m_particleScratch1;
 
  mutable EBAMRCellData m_particleScratchD;
 
  mutable EBAMRIVData m_fluidScratchEB;
 
  mutable EBAMRIVData m_particleScratchEB;
 
  Vector<EBAMRCellData> m_fluidScratchIto;
 
  virtual void
  allocateInternals() noexcept;
 
  virtual void
  setupIto() noexcept;
 
  virtual void
  setupCdr() noexcept;
 
  virtual void
  setupRadiativeTransfer() noexcept;
 
  virtual void
  setupPoisson() noexcept;
 
  virtual void
  setupSigma() noexcept;
 
  virtual void
  intersectParticles(
    const SpeciesSubset                                               a_speciesSubset,
    const bool                                                        a_delete,
    const std::function<void(ParticleSoA<ItoParticle>&, std::size_t)> a_nonDeletionModifier =
      [](ParticleSoA<ItoParticle>&, std::size_t) -> void {
      return;
    }) noexcept;
 
  virtual void
  intersectParticles(
    const SpeciesSubset                                               a_speciesSubset,
    const ItoSolver::WhichContainer                                   a_containerBulk,
    const ItoSolver::WhichContainer                                   a_containerEB,
    const ItoSolver::WhichContainer                                   a_containerDomain,
    const bool                                                        a_delete,
    const std::function<void(ParticleSoA<ItoParticle>&, std::size_t)> a_nonDeletionModifier =
      [](ParticleSoA<ItoParticle>&, std::size_t) -> void {
      return;
    }) noexcept;
 
  virtual void
  removeCoveredParticles(const SpeciesSubset    a_which,
                         const EBRepresentation a_representation,
                         const Real             a_tolerance) noexcept;
 
  virtual void
  removeCoveredParticles(const SpeciesSubset             a_which,
                         const ItoSolver::WhichContainer a_container,
                         const EBRepresentation          a_representation,
                         const Real                      a_tolerance) noexcept;
 
  virtual void
  transferCoveredParticles(const SpeciesSubset    a_speciesSubset,
                           const EBRepresentation a_representation,
                           const Real             a_tolerance) noexcept;
 
  virtual void
  transferCoveredParticles(const SpeciesSubset             a_speciesSubset,
                           const ItoSolver::WhichContainer a_containerFrom,
                           const ItoSolver::WhichContainer a_containerTo,
                           const EBRepresentation          a_representation,
                           const Real                      a_tolerance) noexcept;
 
  virtual void
  writeData(LevelData<EBCellFAB>& a_output,
            int&                  a_comp,
            const EBAMRCellData&  a_data,
            const std::string     a_outputRealm,
            const int             a_level,
            const bool            a_interpToCentroids,
            const bool            a_interpGhost) const noexcept;
 
  virtual void
  writeNumberOfParticlesPerPatch(LevelData<EBCellFAB>& a_output,
                                 int&                  a_icomp,
                                 const std::string     a_outputRealm,
                                 const int             a_level) const noexcept;
 
  virtual void
  getMaxMinRelativeItoDensity(Real&        a_maxDensity,
                              Real&        a_minDensity,
                              std::string& a_maxSolver,
                              std::string& a_minSolver) const noexcept;
 
  virtual void
  getMaxMinRelativeCDRDensity(Real&        a_maxDensity,
                              Real&        a_minDensity,
                              std::string& a_maxSolver,
                              std::string& a_minSolver) const noexcept;
 
  virtual void
  getParticleStatistics(Real& a_avgParticles,
                        Real& a_sigma,
                        Real& a_minParticles,
                        Real& a_maxParticles,
                        int&  a_minRank,
                        int&  a_maxRank);
 
  virtual void
  loadBalanceParticleRealm(Vector<Vector<int>>&             a_procs,
                           Vector<Vector<Box>>&             a_boxes,
                           const std::string                a_realm,
                           const Vector<DisjointBoxLayout>& a_grids,
                           const int                        a_lmin,
                           const int                        a_finestLevel) noexcept;
 
  virtual void
  loadBalanceFluidRealm(Vector<Vector<int>>&             a_procs,
                        Vector<Vector<Box>>&             a_boxes,
                        const std::string                a_realm,
                        const Vector<DisjointBoxLayout>& a_grids,
                        const int                        a_lmin,
                        const int                        a_finestLevel) noexcept;
 
  virtual Vector<RefCountedPtr<ItoSolver>>
  getLoadBalanceSolvers() const noexcept;
 
  virtual void
  fillNeutralDensity() noexcept;
 
  virtual Real
  computeMaxReducedElectricField(const phase::which_phase a_phase) const noexcept;
 
  virtual void
  computeSpaceChargeDensity() noexcept;
 
  virtual void
  computeSpaceChargeDensity(MFAMRCellData&                a_rho,
                            const Vector<EBAMRCellData*>& a_itoDensities,
                            const Vector<EBAMRCellData*>& a_cdrDensities) noexcept;
 
  virtual void
  computeConductivityCell(EBAMRCellData& a_conductivity) noexcept;
 
  virtual void
  computeConductivityCell(EBAMRCellData&                                 a_conductivity,
                          const Vector<ParticleContainer<ItoParticle>*>& a_particles) noexcept;
 
  virtual void
  computeDensityGradients() noexcept;
 
  virtual void
  computeCurrentDensity(EBAMRCellData& a_J) noexcept;
 
  virtual Real
  computeRelaxationTime() noexcept;
 
  virtual bool
  solvePoisson() noexcept;
 
  virtual void
  depositParticles(const SpeciesSubset a_speciesSubset) noexcept;
 
  virtual void
  depositParticles(const SpeciesSubset a_speciesSubset, const ItoSolver::WhichContainer a_container) noexcept;
 
  virtual void
  remapParticles(const SpeciesSubset a_speciesSubset) noexcept;
 
  virtual void
  remapParticles(const SpeciesSubset a_speciesSubset, const ItoSolver::WhichContainer a_container) noexcept;
 
  virtual void
  computeDriftVelocities() noexcept;
 
  virtual void
  setItoVelocityFunctions() noexcept;
 
  virtual void
  setCdrVelocityFunctions() noexcept;
 
  virtual void
  multiplyCdrVelocitiesByMobilities() noexcept;
 
  virtual void
  computeMobilities() noexcept;
 
  virtual void
  computeMobilities(Vector<EBAMRCellData*>& a_itoMobilities,
                    Vector<EBAMRCellData>&  a_cdrMobilities,
                    const EBAMRCellData&    a_electricField,
                    const Real              a_time) noexcept;
 
  virtual void
  computeMobilities(Vector<LevelData<EBCellFAB>*>& a_itoMobilities,
                    Vector<LevelData<EBCellFAB>*>& a_cdrMobilities,
                    const LevelData<EBCellFAB>&    a_E,
                    const int                      a_level,
                    const Real                     a_time) noexcept;
 
  virtual void
  computeMobilities(Vector<EBCellFAB*>& a_itoMobilities,
                    Vector<EBCellFAB*>& a_cdrMobilities,
                    const EBCellFAB&    a_electricField,
                    const int           a_level,
                    const DataIndex     a_din,
                    const Box           a_cellBox,
                    const Real          a_time) noexcept;
 
  virtual void
  computeDiffusionCoefficients() noexcept;
 
  virtual void
  computeDiffusionCoefficients(Vector<EBAMRCellData*>& a_itoDiffusionCoefficients,
                               Vector<EBAMRCellData*>& a_cdrDiffusionCoefficients,
                               const EBAMRCellData&    a_electricField,
                               const Real              a_time) noexcept;
 
  virtual void
  computeDiffusionCoefficients(Vector<LevelData<EBCellFAB>*>& a_itoDiffusionCoefficients,
                               Vector<LevelData<EBCellFAB>*>& a_cdrDiffusionCoefficients,
                               const LevelData<EBCellFAB>&    a_electricField,
                               const int                      a_level,
                               const Real                     a_time) noexcept;
 
  virtual void
  computeDiffusionCoefficients(Vector<EBCellFAB*>& a_itoDiffusionCoefficients,
                               Vector<EBCellFAB*>& a_cdrDiffusionCoefficients,
                               const EBCellFAB&    a_E,
                               const int           a_level,
                               const DataIndex     a_din,
                               const Box           a_box,
                               const Real          a_time) noexcept;
 
  virtual void
  averageDiffusionCoefficientsCellToFace() noexcept;
 
  virtual void
  getPhysicalParticlesPerCell(EBAMRCellData& a_ppc) const noexcept;
 
  virtual void
  computeReactiveItoParticlesPerCell(EBAMRCellData& a_ppc) noexcept;
 
  virtual void
  computeReactiveItoParticlesPerCell(LevelData<EBCellFAB>& a_ppc, const int a_level) noexcept;
 
  virtual void
  computeReactiveItoParticlesPerCell(EBCellFAB&      a_ppc,
                                     const int       a_level,
                                     const DataIndex a_din,
                                     const Box       a_box,
                                     const EBISBox&  a_ebisbox) noexcept;
 
  virtual void
  computeReactiveCdrParticlesPerCell(EBAMRCellData& a_ppc) noexcept;
 
  virtual void
  computeReactiveCdrParticlesPerCell(LevelData<EBCellFAB>& a_ppc, const int a_level) noexcept;
 
  virtual void
  computeReactiveCdrParticlesPerCell(EBCellFAB&      a_ppc,
                                     const int       a_level,
                                     const DataIndex a_din,
                                     const Box       a_box,
                                     const EBISBox&  a_ebisbox) noexcept;
 
  virtual void
  computeReactiveMeanEnergiesPerCell(EBAMRCellData& a_meanEnergies) noexcept;
 
  virtual void
  computeReactiveMeanEnergiesPerCell(LevelData<EBCellFAB>& a_meanEnergies, const int a_level) noexcept;
 
  virtual void
  computeReactiveMeanEnergiesPerCell(EBCellFAB&      a_meanEnergies,
                                     const int       a_level,
                                     const DataIndex a_din,
                                     const Box       a_box,
                                     const EBISBox&  a_ebisbox) noexcept;
 
  virtual void
  advanceReactionNetwork(const Real a_dt) noexcept;
 
  virtual void
  advanceReactionNetwork(const EBAMRCellData& a_E, const Real a_dt) noexcept;
 
  inline void
  advanceReactionNetwork(LevelData<EBCellFAB>&       a_particlesPerCell,
                         LevelData<EBCellFAB>&       a_newPhotonsPerCell,
                         const LevelData<EBCellFAB>& a_electricField,
                         const int                   a_level,
                         const Real                  a_dt) const noexcept;
 
  inline void
  advanceReactionNetwork(EBCellFAB&       a_particlesPerCell,
                         EBCellFAB&       a_newPhotonsPerCell,
                         const EBCellFAB& a_electricField,
                         const int        a_level,
                         const DataIndex  a_din,
                         const Box        a_box,
                         const Real       a_dx,
                         const Real       a_dt) const noexcept;
 
  inline void
  reconcileParticles(const EBAMRCellData& a_newParticlesPerCell,
                     const EBAMRCellData& a_oldParticlesPerCell,
                     const EBAMRCellData& a_newPhotonsPerCell,
                     const EBAMRCellData& a_cdrProduction,
                     const EBAMRCellData& a_electricField) const noexcept;
 
  inline void
  reconcileParticles(const LevelData<EBCellFAB>& a_newParticlesPerCell,
                     const LevelData<EBCellFAB>& a_oldParticlesPerCell,
                     const LevelData<EBCellFAB>& a_newPhotonsPerCell,
                     const LevelData<EBCellFAB>& a_cdrProduction,
                     const LevelData<EBCellFAB>& a_electricField,
                     const int                   a_level) const noexcept;
 
  inline void
  reconcileParticles(const EBCellFAB& a_newParticlesPerCell,
                     const EBCellFAB& a_oldParticlesPerCell,
                     const EBCellFAB& a_newPhotonsPerCell,
                     const EBCellFAB& a_cdrProduction,
                     const EBCellFAB& a_electricField,
                     const int        a_level,
                     const DataIndex  a_din,
                     const Box        a_box,
                     const Real       a_dx) const noexcept;
 
  virtual void
  reconcilePhotoionization() noexcept;
 
  virtual void
  depositCdrProducts(EBAMRCellData& a_cdrChange) noexcept;
 
  virtual void
  reconcileCdrDensities(const EBAMRCellData& a_cdrChange, const Real a_dt) noexcept;
 
  virtual void
  reconcileCdrDensities(const LevelData<EBCellFAB>& a_cdrChange, const int a_level, const Real a_dt) noexcept;
 
  virtual void
  reconcileCdrDensities(const EBCellFAB& a_cdrChange,
                        const int        a_level,
                        const DataIndex  a_din,
                        const Box        a_box,
                        const Real       a_dx,
                        const Real       a_dt) noexcept;
 
  virtual void
  coarsenCDRSolvers(const bool a_interpGhosts) noexcept;
 
  virtual bool
  needSecondaryEmissionEB() const noexcept;
 
  virtual void
  fillSecondaryEmissionEB(const Real a_dt) noexcept;
 
  virtual void
  fillSecondaryEmissionEB(Vector<RefCountedPtr<ParticleContainer<ItoParticle>>>& a_secondaryParticles,
                          Vector<EBAMRIVData>&                                   a_cdrFluxes,
                          Vector<RefCountedPtr<ParticleContainer<Photon>>>&      a_secondaryPhotons,
                          Vector<ParticleContainer<ItoParticle>*>&               a_primaryParticles,
                          Vector<EBAMRIVData>&                                   a_cdrFluxesExtrap,
                          Vector<ParticleContainer<Photon>*>&                    a_primaryPhotons,
                          const EBAMRCellData&                                   a_electricField,
                          const Real                                             a_dt) noexcept;
 
  virtual void
  resolveSecondaryEmissionEB(const Real a_dt) noexcept;
 
  virtual void
  resolveSecondaryEmissionEB(Vector<ParticleContainer<ItoParticle>*>& a_secondaryParticles,
                             Vector<ParticleContainer<ItoParticle>*>& a_primaryParticles,
                             Vector<EBAMRIVData*>&                    a_cdrFluxes,
                             EBAMRIVData&                             a_surfaceChargeDensity,
                             const Real                               a_dt) noexcept;
 
  virtual void
  computePhysicsDt() noexcept;
 
  virtual void
  computeDummyPhysicsDt() noexcept;
 
  virtual Real
  computeTotalCharge() const noexcept;
 
  virtual Real
  computeQplus() const noexcept;
 
  virtual Real
  computeQminu() const noexcept;
 
  virtual Real
  computeQsurf() const noexcept;
 
  virtual void
  advancePhotons(const Real a_dt) noexcept;
 
  virtual void
  sortPhotonsByCell(const McPhoto::WhichContainer a_which) noexcept;
 
  virtual void
  sortPhotonsByPatch(const McPhoto::WhichContainer a_which) noexcept;
 
  virtual void
  postCheckpointPoisson() noexcept;
 
  virtual void
  computeEdotJSource(const Real a_dt) noexcept;
 
  virtual void
  initialSigma() noexcept;
 
  virtual void
  parseVerbosity() noexcept;
 
  virtual void
  parseExitOnFailure() noexcept;
 
  virtual void
  parseRedistributeCDR() noexcept;
 
  virtual void
  parseCdrProducts() noexcept;
 
  virtual void
  parseSuperParticles() noexcept;
 
  virtual void
  parseDualGrid() noexcept;
 
  virtual void
  parseLoadBalance() noexcept;
 
  virtual void
  parseTimeStepRestrictions() noexcept;
 
  virtual void
  parseParametersEB() noexcept;
 
  virtual void
  parsePlotVariables() noexcept;
 
  virtual void
  computePhysicsPlotVariables(EBAMRCellData& a_physicsPlotVars) noexcept;
};
} // namespace ItoKMC
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#include <CD_ItoKMCStepperImplem.H>
 
#endif