CD_ItoKMCStepper.H

Go to the documentation of this file.

/* chombo-discharge
 * Copyright © 2021 SINTEF Energy Research.
 * Please refer to Copyright.txt and LICENSE in the chombo-discharge root directory.
 */
 
#ifndef CD_ItoKMCStepper_H
#define CD_ItoKMCStepper_H
 
// Std includes
#include <functional>
 
// Our includes
#include <CD_TimeStepper.H>
#include <CD_ItoKMCPhysics.H>
#include <CD_ItoLayout.H>
#include <CD_CdrLayout.H>
#include <CD_PointParticle.H>
#include <CD_RtLayout.H>
#include <CD_McPhoto.H>
#include "CD_FieldSolver.H"
#include "CD_ItoSolver.H"
#include "CD_CdrCTU.H"
#include "CD_FieldSolverMultigrid.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 = FieldSolverMultigrid>
    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, FieldSolverMultigrid>::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
      };
 
      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<ParticleContainer<ItoParticle>> m_secondaryParticles;
 
      Vector<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;
 
      bool m_dualGrid;
 
      bool m_profile;
 
      bool m_regridSuperparticles;
 
      bool m_loadBalanceParticles;
 
      bool m_loadBalanceFluid;
 
      bool m_plotConductivity;
 
      bool m_plotCurrentDensity;
 
      bool m_plotParticlesPerPatch;
 
      Vector<int> m_particlesPerCell;
 
      int m_mergeInterval;
 
      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;
 
      Vector<EBAMRCellData> m_loadBalancePPC;
 
      Vector<EBAMRCellData> m_cdrMobilities;
 
      Vector<EBAMRCellData> m_fluidGradPhiCDR;
 
      Vector<EBAMRCellData> m_fluidGradPhiIto;
 
      Vector<EBAMRCellData> m_fluidPhiIto;
 
      mutable Vector<ParticleContainer<PointParticle>> m_cdrPhotoiProducts;
 
      Vector<int> m_loadBalanceIndices;
 
      EBAMRCellData m_currentDensity;
 
      EBAMRCellData m_physicsPlotVariables;
 
      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;
 
      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;
 
      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(ItoParticle&)> a_nonDeletionModifier = [](ItoParticle&) -> 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(ItoParticle&)> a_nonDeletionModifier = [](ItoParticle&) -> 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
      getMaxMinItoDensity(Real&        a_maxDensity,
                          Real&        a_minDensity,
                          std::string& a_maxSolver,
                          std::string& a_minSolver) const noexcept;
 
      virtual void
      getMaxMinCDRDensity(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 Real
      computeMaxElectricField(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_dit,
                        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_dit,
                                   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_dit,
                                         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_dit,
                                         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_dit,
                                         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_dit,
                             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 noexcept;
 
      inline void
      reconcileParticles(const LevelData<EBCellFAB>& a_newParticlesPerCell,
                         const LevelData<EBCellFAB>& a_oldParticlesPerCell,
                         const LevelData<EBCellFAB>& a_newPhotonsPerCell,
                         const int                   a_level) const noexcept;
 
      inline void
      reconcileParticles(const EBCellFAB& a_newParticlesPerCell,
                         const EBCellFAB& a_oldParticlesPerCell,
                         const EBCellFAB& a_newPhotonsPerCell,
                         const int        a_level,
                         const DataIndex  a_dit,
                         const Box        a_box,
                         const Real       a_dx) const noexcept;
 
      virtual void
      reconcilePhotoionization() noexcept;
 
      virtual void
      reconcileCdrDensities(const EBAMRCellData& a_newParticlesPerCell,
                            const EBAMRCellData& a_oldParticlesPerCell,
                            const Real           a_dt) noexcept;
 
      virtual void
      reconcileCdrDensities(const LevelData<EBCellFAB>& a_newParticlesPerCell,
                            const LevelData<EBCellFAB>& a_oldParticlesPerCell,
                            const int                   a_level,
                            const Real                  a_dt) noexcept;
 
      virtual void
      reconcileCdrDensities(const EBCellFAB& a_newParticlesPerCell,
                            const EBCellFAB& a_oldParticlesPerCell,
                            const int        a_level,
                            const DataIndex  a_dit,
                            const Box        a_box,
                            const Real       a_dx,
                            const Real       a_dt) noexcept;
 
      virtual void
      coarsenCDRSolvers() noexcept;
 
      virtual void
      fillSecondaryEmissionEB(const Real a_dt) noexcept;
 
      virtual void
      fillSecondaryEmissionEB(Vector<ParticleContainer<ItoParticle>>&  a_secondaryParticles,
                              Vector<EBAMRIVData>&                     a_cdrFluxes,
                              Vector<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 Real
      computePhysicsDt() noexcept;
 
      virtual Real
      computePhysicsDt(const EBAMRCellData& a_electricField) noexcept;
 
      virtual Real
      computePhysicsDt(const LevelData<EBCellFAB>& a_electricField,
                       const LevelData<EBCellFAB>& a_particlesPerCell,
                       const int                   a_level) noexcept;
 
      virtual Real
      computePhysicsDt(const EBCellFAB& a_electricField,
                       const EBCellFAB& a_particlesPercCell,
                       const int        a_level,
                       const DataIndex  a_dit,
                       const Box        a_box) 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
      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