CD_ItoPlasmaStepper.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_ItoPlasmaStepper_H
#define CD_ItoPlasmaStepper_H
 
// Std includes
#include <functional>
 
// Our includes
#include <CD_TimeStepper.H>
#include <CD_ItoPlasmaPhysics.H>
#include <CD_ItoLayout.H>
#include <CD_PointParticle.H>
#include <CD_RtLayout.H>
#include <CD_McPhoto.H>
#include "CD_FieldSolver.H"
#include "CD_SurfaceODESolver.H"
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace ItoPlasma {
 
    enum class SpeciesSubset
    {
      All,
      AllMobile,
      AllDiffusive,
      AllMobileOrDiffusive,
      AllMobileAndDiffusive,
      Charged,
      ChargedMobile,
      ChargedDiffusive,
      ChargedMobileOrDiffusive,
      ChargedMobileAndDiffusive,
      Stationary,
    };
 
    class ItoPlasmaStepper : public TimeStepper
    {
    public:
      ItoPlasmaStepper();
 
      ItoPlasmaStepper(RefCountedPtr<ItoPlasmaPhysics>& a_physics);
 
      virtual ~ItoPlasmaStepper();
 
      virtual void
      parseOptions();
 
      virtual void
      parseRuntimeOptions() override;
 
      virtual void
      allocate() override;
 
      virtual void
      allocateInternals();
 
      virtual void
      setupSolvers() override;
 
      virtual void
      initialData() override;
 
      virtual void
      postCheckpointSetup() override;
 
      virtual void
      postCheckpointPoisson();
 
      virtual void
      postInitialize() override;
 
#ifdef CH_USE_HDF5
      virtual void
      readCheckpointHeader(HDF5HeaderData& a_header);
#endif
 
#ifdef CH_USE_HDF5
      virtual void
      writeCheckpointHeader(HDF5HeaderData& a_header) const override;
#endif
 
#ifdef CH_USE_HDF5
      virtual void
      writeCheckpointData(HDF5Handle& a_handle, const int a_lvl) const override;
#endif
 
#ifdef CH_USE_HDF5
      virtual void
      readCheckpointData(HDF5Handle& a_handle, const int a_lvl) override;
#endif
 
      virtual void
      writePlotData(EBAMRCellData& a_output, Vector<std::string>& a_plotVariableNames, int& a_icomp) const override;
 
      virtual int
      getNumberOfPlotVariables() const override;
 
      virtual Vector<long int>
      getCheckpointLoads(const std::string a_realm, const int a_level) const override;
 
      virtual Real
      advance(const Real a_dt) = 0;
 
      virtual Real
      computeDt() override;
 
      virtual void
      synchronizeSolverTimes(const int a_step, const Real a_time, const Real a_dt) override;
 
      virtual void
      printStepReport() override;
 
      virtual void
      registerRealms() override;
 
      virtual void
      registerOperators() override;
 
      virtual void
      preRegrid(const int a_lmin, const int a_oldFinestLevel) override;
 
      virtual void
      regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
      virtual void
      postRegrid() 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
      setIto(RefCountedPtr<ItoLayout<ItoSolver>>& a_itoLayout) noexcept;
 
      virtual void
      setFieldSolver(RefCountedPtr<FieldSolver>& a_fieldSolver) noexcept;
 
      virtual void
      setRadiativeTransferSolvers(RefCountedPtr<RtLayout<McPhoto>>& a_rteLayout) noexcept;
 
      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
      {
        Advection,
        Diffusion,
        AdvectionDiffusion,
        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<ItoPlasmaPhysics> m_physics;
 
      RefCountedPtr<ItoLayout<ItoSolver>> m_ito;
 
      RefCountedPtr<RtLayout<McPhoto>> m_rte;
 
      RefCountedPtr<FieldSolver> m_fieldSolver;
 
      RefCountedPtr<SurfaceODESolver<1>> m_sigmaSolver;
 
      std::function<Real(const Real a_time)> m_voltage;
 
      bool m_abortOnFailure;
 
      bool m_dualGrid;
 
      bool m_profile;
 
      bool m_regridSuperparticles;
 
      bool m_loadBalanceParticles;
 
      bool m_loadBalanceFluid;
 
      bool m_useNewReactionAlgorithm;
 
      bool m_plotConductivity;
 
      bool m_plotCurrentDensity;
 
      bool m_plotParticlesPerPatch;
 
      Vector<int> m_particlesPerCell;
 
      int m_mergeInterval;
 
      Real m_loadPerCell;
 
      Real m_toleranceEB;
 
      Real m_advectionCFL;
 
      Real m_diffusionCFL;
 
      Real m_advectionDiffusionCFL;
 
      Real m_relaxTimeFactor;
 
      Real m_minDt;
 
      Real m_maxDt;
 
      Real m_advectionDt;
 
      Real m_diffusionDt;
 
      Real m_advectionDiffusionDt;
 
      Real m_relaxationTime;
 
      Real m_physicsDt;
 
      Vector<EBAMRCellData> m_loadBalancePPC;
 
      Vector<int> m_loadBalanceIndices;
 
      EBAMRCellData m_currentDensity;
 
      EBAMRCellData m_conductivityCell;
 
      EBAMRFluxData m_conductivityFace;
 
      EBAMRIVData m_conductivityEB;
 
      EBAMRCellData m_oldPPC;
 
      EBAMRCellData m_newPPC;
 
      EBAMRCellData m_particlePPC;
 
      EBAMRCellData m_particleYPC;
 
      EBAMRCellData m_particleEPS;
 
      EBAMRCellData m_particleOldPPC;
 
      EBAMRCellData m_fluidPPC;
 
      EBAMRCellData m_fluidYPC;
 
      EBAMRCellData m_fluidEPS;
 
      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;
 
      virtual void
      setupIto();
 
      virtual void
      setupPoisson();
 
      virtual void
      setupRadiativeTransfer();
 
      virtual void
      setupSigma();
 
      virtual void
      intersectParticles(const SpeciesSubset  a_speciesSubset,
                         const EBIntersection a_interactionAlg,
                         const bool           a_delete) noexcept;
 
      virtual void
      intersectParticles(const SpeciesSubset             a_speciesSubset,
                         const ItoSolver::WhichContainer a_containerBulk,
                         const ItoSolver::WhichContainer a_containerEB,
                         const ItoSolver::WhichContainer a_containerDomain,
                         const EBIntersection            a_intersectionAlg,
                         const bool                      a_delete) 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
      writeNumParticlesPerPatch(EBAMRCellData& a_output, int& a_icomp) const;
 
      virtual void
      getMaxMinItoDensity(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) noexcept;
 
      virtual void
      computeSpaceChargeDensity() noexcept;
 
      virtual void
      computeSpaceChargeDensity(MFAMRCellData& a_rho, const Vector<EBAMRCellData*>& a_densities) noexcept;
 
      virtual void
      computeConductivityCell(EBAMRCellData& a_conductivity) noexcept;
 
      virtual void
      computeConductivityCell(EBAMRCellData&                                 a_conductivity,
                              const Vector<ParticleContainer<ItoParticle>*>& a_particles) 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
      setItoVelocityFunctions() noexcept;
 
      virtual void
      computeItoVelocities() noexcept;
 
      virtual void
      computeItoDiffusion() noexcept;
 
      virtual void
      computeItoMobilitiesLFA() noexcept;
 
      virtual void
      computeItoMobilitiesLFA(Vector<EBAMRCellData*>& a_meshMobilities,
                              const EBAMRCellData&    a_electricField,
                              const Real              a_time) noexcept;
 
      virtual void
      computeItoMobilitiesLFA(Vector<LevelData<EBCellFAB>*>& a_meshMobilities,
                              const LevelData<EBCellFAB>&    a_E,
                              const int                      a_level,
                              const Real                     a_time) noexcept;
 
      virtual void
      computeItoMobilitiesLFA(Vector<EBCellFAB*>& a_meshMobilities,
                              const EBCellFAB&    a_electricField,
                              const int           a_level,
                              const DataIndex     a_dit,
                              const Box           a_cellBox,
                              const Real          a_time) noexcept;
 
      virtual void
      computeItoMobilitiesLEA() noexcept;
 
      virtual void
      computeItoDiffusionLFA() noexcept;
 
      virtual void
      computeItoDiffusionLFA(Vector<EBAMRCellData*>& a_diffusionCoefficient,
                             const EBAMRCellData&    a_electricField,
                             const Real              a_time) noexcept;
 
      virtual void
      computeItoDiffusionLFA(Vector<LevelData<EBCellFAB>*>& a_diffusionCoefficient,
                             const LevelData<EBCellFAB>&    a_electricField,
                             const int                      a_level,
                             const Real                     a_time) noexcept;
 
      virtual void
      computeItoDiffusionLFA(Vector<EBCellFAB*>& a_diffusionCoefficient,
                             const EBCellFAB&    a_E,
                             const int           a_level,
                             const DataIndex     a_dit,
                             const Box           a_box,
                             const Real          a_time) noexcept;
 
      virtual void
      computeItoDiffusionLEA() noexcept;
 
      virtual void
      getPhysicalParticlesPerCell(EBAMRCellData& a_ppc) const noexcept;
 
      virtual void
      computeReactiveParticlesPerCell(EBAMRCellData& a_ppc) noexcept;
 
      virtual void
      computeReactiveParticlesPerCell(LevelData<EBCellFAB>& a_ppc, const int a_level) noexcept;
 
      virtual void
      computeReactiveParticlesPerCell(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 EBAMRCellData& a_EdotJ, const Real a_dt) noexcept;
 
      virtual void
      advanceReactionNetwork(LevelData<EBCellFAB>&       a_particlesPerCell,
                             LevelData<EBCellFAB>&       a_newPhotonsPerCell,
                             LevelData<EBCellFAB>&       a_meanParticleEnergies,
                             const LevelData<EBCellFAB>& a_electricField,
                             const LevelData<EBCellFAB>& a_EdotJ,
                             const int                   a_level,
                             const Real                  a_dt) noexcept;
 
      virtual void
      advanceReactionNetwork(EBCellFAB&       a_particlesPerCell,
                             EBCellFAB&       a_newPhotonsPerCell,
                             EBCellFAB&       a_meanParticleEnergies,
                             const EBCellFAB& a_electricField,
                             const EBCellFAB& a_EdotJ,
                             const int        a_level,
                             const DataIndex  a_dit,
                             const Box        a_box,
                             const Real       a_dx,
                             const Real       a_dt) noexcept;
 
      virtual void
      reconcileParticles(const EBAMRCellData& a_newParticlesPerCell,
                         const EBAMRCellData& a_oldParticlesPerCell,
                         const EBAMRCellData& a_meanParticleEnergies,
                         const EBAMRCellData& a_newPhotonsPerCell) noexcept;
 
      virtual void
      reconcileParticles(const LevelData<EBCellFAB>& a_newParticlesPerCell,
                         const LevelData<EBCellFAB>& a_oldParticlesPerCell,
                         const LevelData<EBCellFAB>& a_meanParticleEnergies,
                         const LevelData<EBCellFAB>& a_newPhotonsPerCell,
                         const int                   a_level) noexcept;
 
      virtual void
      reconcileParticles(const EBCellFAB& a_newParticlesPerCell,
                         const EBCellFAB& a_oldParticlesPerCell,
                         const EBCellFAB& a_meanParticleEnergies,
                         const EBCellFAB& a_newPhotonsPerCell,
                         const int        a_level,
                         const DataIndex  a_dit,
                         const Box        a_box,
                         const Real       a_dx) noexcept;
 
      virtual void
      resolveParticlesEB(const Real a_dt) noexcept;
 
      virtual void
      resolveParticlesEB(Vector<ParticleContainer<ItoParticle>*>& a_inOutParticles,
                         Vector<ParticleContainer<Photon>*>&      a_inOutPhotons,
                         const EBAMRCellData&                     a_electricField,
                         const Real                               a_dt) noexcept;
 
      virtual void
      injectParticlesEB() noexcept;
 
      virtual void
      injectParticlesEB(Vector<ParticleContainer<ItoParticle>*> a_bulkParticles,
                        Vector<ParticleContainer<ItoParticle>*> a_injectedParticles) 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 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
      computeEdotJSource(const Real a_dt) noexcept;
 
      virtual void
      initialSigma();
 
      virtual void
      parseVerbosity() noexcept;
 
      virtual void
      parseAbort() 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;
    };
  } // namespace ItoPlasma
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif