CD_CdrPlasmaStepper.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_CdrPlasmaStepper_H
#define CD_CdrPlasmaStepper_H
 
// Std includes
#include <functional>
 
// Our includes
#include <CD_ComputationalGeometry.H>
#include <CD_CdrPlasmaPhysics.H>
#include <CD_AmrMesh.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_CdrLayout.H>
#include <CD_RtLayout.H>
#include <CD_FieldSolver.H>
#include <CD_SurfaceODESolver.H>
#include <CD_TimeStepper.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace CdrPlasma {
 
    class CdrPlasmaStepper : public TimeStepper
    {
    public:
      CdrPlasmaStepper();
 
      CdrPlasmaStepper(RefCountedPtr<CdrPlasmaPhysics>& a_physics);
 
      ~CdrPlasmaStepper();
 
      virtual void
      setupSolvers() override;
 
      virtual void
      allocate() override;
 
      virtual void
      initialData() override;
 
      virtual void
      postInitialize() override;
 
      virtual void
      postCheckpointSetup() override;
 
      virtual void
      registerRealms() override;
 
      virtual void
      registerOperators() override;
 
      virtual void
      parseRuntimeOptions() override = 0;
 
      virtual void
      prePlot() override;
 
#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 int
      getNumberOfPlotVariables() const override;
 
      virtual Vector<std::string>
      getPlotVariableNames() const override;
 
      virtual void
      writePlotData(LevelData<EBCellFAB>& a_output,
                    int&                  a_icomp,
                    const std::string     a_outputRealm,
                    const int             a_level) const override;
 
      virtual Real
      computeDt() override = 0;
 
      virtual Real
      advance(const Real a_dt) override = 0;
 
      virtual void
      synchronizeSolverTimes(const int a_step, const Real a_time, const Real a_dt) override;
 
      virtual void
      printStepReport() override;
 
      virtual void
      preRegrid(const int a_lmin, const int a_oldFinestLevel) override;
 
      virtual void
      preRegridInternals(const int a_lmin, const int a_oldFinestLevel);
 
      virtual void
      regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
      virtual void
      postRegrid() override;
 
      virtual void
      computeJ(EBAMRCellData& a_J) const;
 
      virtual void
      computeElectricField(MFAMRCellData& a_electricFieldCell, const MFAMRCellData& a_potential) const;
 
      virtual void
      computeElectricField(EBAMRCellData& a_electricFieldCell, const phase::which_phase a_phase) const;
 
      virtual void
      computeElectricField(EBAMRCellData&           a_E,
                           const phase::which_phase a_phase,
                           const MFAMRCellData&     a_potential) const;
 
      virtual void
      computeElectricField(EBAMRFluxData&           a_electricFieldFace,
                           const phase::which_phase a_phase,
                           const EBAMRCellData&     a_electricFieldCell) const;
 
      virtual void
      computeElectricField(EBAMRIVData&             a_electricFieldEB,
                           const phase::which_phase a_phase,
                           const EBAMRCellData&     a_electricFieldCell) const;
 
      virtual void
      computeMaxElectricField(Real& a_maxElectricField, const phase::which_phase a_phase);
 
      virtual Real
      getTime() const;
 
      virtual bool
      stationaryRTE();
 
      virtual void
      allocateInternals() = 0;
 
      virtual void
      deallocateInternals() = 0;
 
      virtual void
      parseOptions() = 0;
 
      virtual void
      deallocate();
 
      virtual void
      computeSpaceChargeDensity();
 
      virtual void
      computeSpaceChargeDensity(MFAMRCellData& a_rho, const Vector<EBAMRCellData*>& a_cdrDensities);
 
      virtual void
      computeCellConductivity(EBAMRCellData& a_cellConductivity) const;
 
      virtual void
      computeFaceConductivity(EBAMRFluxData&       a_conductivityFace,
                              EBAMRIVData&         a_conductivityEB,
                              const EBAMRCellData& a_conductivityCell) const;
 
      virtual void
      setupSemiImplicitPoisson(const Real a_dt);
 
      virtual void
      setupSemiImplicitPoisson(const EBAMRFluxData& a_conductivityFace,
                               const EBAMRIVData&   a_conductivityEB,
                               const Real           a_factor);
 
      virtual bool
      solvePoisson();
 
      virtual bool
      solvePoisson(MFAMRCellData&               a_potential,
                   MFAMRCellData&               a_rho,
                   const Vector<EBAMRCellData*> a_cdrDensities,
                   const EBAMRIVData&           a_sigma);
 
      virtual void
      advanceReactionNetwork(const Real a_time, const Real a_dt);
 
      virtual void
      advanceReactionNetwork(Vector<EBAMRCellData*>&       a_cdrSources,
                             Vector<EBAMRCellData*>&       a_rteSources,
                             const Vector<EBAMRCellData*>& a_cdrDensities,
                             const Vector<EBAMRCellData*>& a_rteDensities,
                             const EBAMRCellData&          a_E,
                             const Real&                   a_time,
                             const Real&                   a_dt);
 
      virtual void
      advanceReactionNetwork(Vector<EBAMRCellData*>&       a_cdrSources,
                             Vector<EBAMRCellData*>&       a_rteSources,
                             const Vector<EBAMRCellData*>& a_cdrDensities,
                             const Vector<EBAMRCellData*>& a_cdrGradients,
                             const Vector<EBAMRCellData*>& a_rteDensities,
                             const EBAMRCellData&          a_E,
                             const Real&                   a_time,
                             const Real&                   a_dt);
 
      virtual void
      advanceReactionNetwork(Vector<LevelData<EBCellFAB>*>&       a_cdrSources,
                             Vector<LevelData<EBCellFAB>*>&       a_rteSources,
                             const Vector<LevelData<EBCellFAB>*>& a_cdrDensities,
                             const Vector<LevelData<EBCellFAB>*>& a_cdrGradients,
                             const Vector<LevelData<EBCellFAB>*>& a_rteDensities,
                             const LevelData<EBCellFAB>&          a_E,
                             const Real&                          a_time,
                             const Real&                          a_dt,
                             const int                            a_level);
      virtual void
      advanceReactionNetworkRegularCells(Vector<FArrayBox*>&       a_cdrSources,
                                         Vector<FArrayBox*>&       a_rteSources,
                                         const Vector<FArrayBox*>& a_cdrDensities,
                                         const Vector<FArrayBox*>& a_cdrGradients,
                                         const Vector<FArrayBox*>& a_rteDensities,
                                         const FArrayBox&          a_E,
                                         const Real&               a_time,
                                         const Real&               a_dt,
                                         const Real&               a_dx,
                                         const Box&                a_cellBox);
 
      virtual void
      advanceReactionNetworkIrreg(Vector<EBCellFAB*>&          a_cdrSources,
                                  Vector<EBCellFAB*>&          a_rteSources,
                                  const Vector<EBCellFAB*>&    a_cdrDensities,
                                  const Vector<EBCellFAB*>&    a_cdrGradients,
                                  const Vector<EBCellFAB*>&    a_cdrVelocities,
                                  const Vector<EBCellFAB*>&    a_rteDensities,
                                  const BaseIVFAB<VoFStencil>& a_interpStencils,
                                  const EBCellFAB&             a_E,
                                  const Real&                  a_time,
                                  const Real&                  a_dt,
                                  const Real&                  a_dx,
                                  const Box&                   a_cellBox,
                                  const int                    a_lvl,
                                  const DataIndex&             a_dit);
 
      virtual void
      advanceReactionNetworkIrregInterp(Vector<EBCellFAB*>&          a_cdrSources,
                                        Vector<EBCellFAB*>&          a_rteSources,
                                        const Vector<EBCellFAB*>&    a_cdrDensities,
                                        const Vector<EBCellFAB*>&    a_cdrGradients,
                                        const Vector<EBCellFAB*>&    a_cdrVelocities,
                                        const Vector<EBCellFAB*>&    a_rteDensities,
                                        const BaseIVFAB<VoFStencil>& a_interpStencils,
                                        const EBCellFAB&             a_E,
                                        const Real&                  a_time,
                                        const Real&                  a_dt,
                                        const Real&                  a_dx,
                                        const Box&                   a_box,
                                        const int                    a_lvl,
                                        const DataIndex&             a_dit);
      virtual void
      advanceReactionNetworkIrregKappa(Vector<EBCellFAB*>&          a_cdrSources,
                                       Vector<EBCellFAB*>&          a_rteSources,
                                       const Vector<EBCellFAB*>&    a_cdrDensities,
                                       const Vector<EBCellFAB*>&    a_cdrGradients,
                                       const Vector<EBCellFAB*>&    a_rteDensities,
                                       const BaseIVFAB<VoFStencil>& a_interpStencils,
                                       const EBCellFAB&             a_E,
                                       const Real&                  a_time,
                                       const Real&                  a_dt,
                                       const Real&                  a_dx,
                                       const Box&                   a_box,
                                       const int                    a_lvl,
                                       const DataIndex&             a_dit);
 
      virtual void
      advanceReactionNetworkIrregUpwind(Vector<EBCellFAB*>&          a_cdrSources,
                                        Vector<EBCellFAB*>&          a_rteSources,
                                        const Vector<EBCellFAB*>&    a_cdrDensities,
                                        const Vector<EBCellFAB*>&    a_cdrGradients,
                                        const Vector<EBCellFAB*>&    a_cdrVelocities,
                                        const Vector<EBCellFAB*>&    a_rteDensities,
                                        const BaseIVFAB<VoFStencil>& a_interpStencils,
                                        const EBCellFAB&             a_E,
                                        const Real&                  a_time,
                                        const Real&                  a_dt,
                                        const Real&                  a_dx,
                                        const Box&                   a_box,
                                        const int                    a_lvl,
                                        const DataIndex&             a_dit);
 
      virtual void
      computeCdrDiffusion();
 
      virtual void
      computeCdrDiffusion(const EBAMRCellData& a_electricFieldCell, const EBAMRIVData& a_electricFieldEB);
 
      virtual void
      computeCdrDiffusionCell(Vector<EBAMRCellData>&        a_cdrDcoCell,
                              const Vector<EBAMRCellData*>& a_cdrDensities,
                              const EBAMRCellData&          a_electricFieldCell,
                              const Real&                   a_time);
 
      virtual void
      computeCdrDiffusionCell(Vector<LevelData<EBCellFAB>*>&       a_cdrDcoCell,
                              const Vector<LevelData<EBCellFAB>*>& a_cdrDensities,
                              const LevelData<EBCellFAB>&          a_electricFieldCell,
                              const int                            a_lvl,
                              const Real&                          a_time);
 
      virtual void
      computeCdrDiffusionCellRegular(Vector<FArrayBox*>&       a_cdrDcoCell,
                                     const Vector<FArrayBox*>& a_cdrDensities,
                                     const FArrayBox&          a_electricFieldCell,
                                     const Box                 a_cellBox,
                                     const Real                a_dx,
                                     const Real                a_time);
 
      virtual void
      computeCdrDiffusionCellIrregular(Vector<EBCellFAB*>&       a_cdrDcoCell,
                                       const Vector<EBCellFAB*>& a_cdrDensities,
                                       const EBCellFAB&          a_electricFieldCell,
                                       const Real                a_dx,
                                       const Real&               a_time,
                                       const int                 a_lvl,
                                       const DataIndex&          a_dit);
 
      virtual void
      computeCdrDiffusionFace(Vector<EBAMRFluxData*>&       a_cdrDcoFace,
                              const Vector<EBAMRCellData*>& a_cdrDensities,
                              const EBAMRCellData&          a_electricFieldCell,
                              const Real&                   a_time);
 
      virtual void
      computeCdrDiffusionEb(Vector<EBAMRIVData*>&       a_cdrDcoEB,
                            const Vector<EBAMRIVData*>& a_cdrDensitiesEB,
                            const EBAMRIVData&          a_electricFieldEB,
                            const Real&                 a_time);
 
      virtual void
      computeCdrDiffusionEb(Vector<LevelData<BaseIVFAB<Real>>*>&       a_cdrDcoEB,
                            const Vector<LevelData<BaseIVFAB<Real>>*>& a_cdrDensitiesEB,
                            const LevelData<BaseIVFAB<Real>>&          a_electricFieldEB,
                            const Real&                                a_time,
                            const int                                  a_lvl);
 
      virtual void
      computeCdrDriftVelocities();
 
      virtual void
      computeCdrDriftVelocities(Vector<EBAMRCellData*>&       a_velocities,
                                const Vector<EBAMRCellData*>& a_cdrDensities,
                                const EBAMRCellData&          a_E,
                                const Real&                   a_time);
 
      virtual void
      computeCdrDriftVelocities(Vector<LevelData<EBCellFAB>*>&       a_cdrVelocities,
                                const Vector<LevelData<EBCellFAB>*>& a_cdrDensities,
                                const LevelData<EBCellFAB>&          a_electricField,
                                const int                            a_lvl,
                                const Real&                          a_time);
 
      virtual void
      computeCdrDriftVelocitiesRegular(Vector<FArrayBox*>&       a_cdrVelocities,
                                       const Vector<FArrayBox*>& a_cdrDensities,
                                       const FArrayBox&          a_electricField,
                                       const Box&                a_cellBox,
                                       const Real&               a_time,
                                       const Real&               a_dx);
 
      virtual void
      computeCdrDriftVelocitiesIrregular(Vector<EBCellFAB*>&       a_velocities,
                                         const Vector<EBCellFAB*>& a_cdrDensities,
                                         const EBCellFAB&          a_electricField,
                                         const Real&               a_time,
                                         const Real&               a_dx,
                                         const int                 a_lvl,
                                         const DataIndex&          a_dit);
 
      virtual void
      computeCdrFluxes(Vector<EBAMRIVData*>&       a_cdrFluxesEB,
                       const Vector<EBAMRIVData*>& a_extrapCdrFluxes,
                       const Vector<EBAMRIVData*>& a_extrapCdrDensities,
                       const Vector<EBAMRIVData*>& a_extrapCdrVelocities,
                       const Vector<EBAMRIVData*>& a_extrapCdrGradients,
                       const Vector<EBAMRIVData*>& a_extrapRteFluxes,
                       const EBAMRIVData&          a_electricField,
                       const Real&                 a_time);
 
      virtual void
      computeCdrFluxes(Vector<LevelData<BaseIVFAB<Real>>*>&       a_cdrFluxesEB,
                       const Vector<LevelData<BaseIVFAB<Real>>*>& a_extrapCdrFluxes,
                       const Vector<LevelData<BaseIVFAB<Real>>*>& a_extrapCdrDensities,
                       const Vector<LevelData<BaseIVFAB<Real>>*>& a_extrapCdrVelocities,
                       const Vector<LevelData<BaseIVFAB<Real>>*>& a_extrapCdrGradients,
                       const Vector<LevelData<BaseIVFAB<Real>>*>& a_extrapRteFluxes,
                       const LevelData<BaseIVFAB<Real>>&          a_electricField,
                       const Real&                                a_time,
                       const int                                  a_lvl);
 
      virtual void
      computeCdrDomainFluxes(Vector<EBAMRIFData*>&       a_cdrFluxes,
                             const Vector<EBAMRIFData*>& a_extrapCdrFluxes,
                             const Vector<EBAMRIFData*>& a_extrapCdrDensities,
                             const Vector<EBAMRIFData*>& a_extrapCdrVelocities,
                             const Vector<EBAMRIFData*>& a_extrapCdrGradients,
                             const Vector<EBAMRIFData*>& a_extrapRteFluxes,
                             const EBAMRIFData&          a_field,
                             const Real&                 a_time);
 
      virtual void
      computeCdrDomainFluxes(Vector<LevelData<DomainFluxIFFAB>*>        a_cdrFluxes,
                             const Vector<LevelData<DomainFluxIFFAB>*>& a_extrapCdrFluxes,
                             const Vector<LevelData<DomainFluxIFFAB>*>& a_extrapCdrDensities,
                             const Vector<LevelData<DomainFluxIFFAB>*>& a_extrapCdrVelocities,
                             const Vector<LevelData<DomainFluxIFFAB>*>& a_extrapCdrGradients,
                             const Vector<LevelData<DomainFluxIFFAB>*>& a_extrapRteFluxes,
                             const LevelData<DomainFluxIFFAB>&          a_electricField,
                             const Real&                                a_time,
                             const int                                  a_lvl);
 
      virtual void
      computeExtrapolatedFluxes(Vector<EBAMRIVData*>&        a_extrapCdrFluxesEB,
                                const Vector<EBAMRCellData*> a_cdrDensities,
                                const Vector<EBAMRCellData*> a_cdrVelocities,
                                const phase::which_phase     a_phase);
 
      virtual void
      computeExtrapolatedDomainFluxes(Vector<EBAMRIFData*>&        a_cdrDomainFluxes,
                                      const Vector<EBAMRCellData*> a_cdrDensities,
                                      const Vector<EBAMRCellData*> a_cdrVelocities,
                                      const phase::which_phase     a_phase);
 
      virtual void
      computeExtrapolatedVelocities(Vector<EBAMRIVData*>&        a_cdrVelocitiesEB,
                                    const Vector<EBAMRCellData*> a_cdrVelocitiesCell,
                                    const phase::which_phase     a_phase);
 
      virtual void
      deallocateSolverInternals();
 
      virtual void
      extrapolateToEb(Vector<EBAMRIVData*>&         a_ebData,
                      const phase::which_phase      a_phase,
                      const Vector<EBAMRCellData*>& a_cellData);
 
      virtual void
      extrapolateToEb(EBAMRIVData& a_ebData, const phase::which_phase a_phase, const EBAMRCellData& a_cellData);
 
      virtual void
      extrapolateToEb(LevelData<BaseIVFAB<Real>>& a_ebData,
                      const phase::which_phase    a_phase,
                      const LevelData<EBCellFAB>& a_cellData,
                      const int                   a_lvl);
 
      virtual void
      extrapolateToDomainFaces(Vector<EBAMRIFData*>&         a_domainData,
                               const phase::which_phase      a_phase,
                               const Vector<EBAMRCellData*>& a_cellData);
 
      virtual void
      extrapolateToDomainFaces(EBAMRIFData&             a_domainData,
                               const phase::which_phase a_phase,
                               const EBAMRCellData&     a_cellData);
 
      virtual void
      extrapolateToDomainFaces(LevelData<DomainFluxIFFAB>& a_domainData,
                               const phase::which_phase    a_phase,
                               const LevelData<EBCellFAB>& a_cellData,
                               const int                   a_lvl);
 
      virtual void
      extrapolateVectorToDomainFaces(Vector<EBAMRIFData*>&         a_domainData,
                                     const phase::which_phase      a_phase,
                                     const Vector<EBAMRCellData*>& a_cellData);
 
      virtual void
      extrapolateVectorToDomainFaces(EBAMRIFData&             a_domainData,
                                     const phase::which_phase a_phase,
                                     const EBAMRCellData&     a_cellData);
 
      virtual void
      extrapolateVelocitiesToDomainFaces(Vector<EBAMRIFData*>&         a_domainVelocities,
                                         const phase::which_phase      a_phase,
                                         const Vector<EBAMRCellData*>& a_cellVelocities);
 
      virtual void
      getCdrMax(Real& a_cdrMax, std::string& a_solverName) const;
 
      virtual void
      initialSigma();
 
      virtual void
      projectFlux(EBAMRIVData& a_projectedFlux, const EBAMRIVData& a_flux);
 
      virtual void
      projectFlux(LevelData<BaseIVFAB<Real>>&       a_projectedFlux,
                  const LevelData<BaseIVFAB<Real>>& a_flux,
                  const int                         a_lvl);
 
      virtual void
      projectDomain(EBAMRIFData& a_projectedFlux, const EBAMRIFData& a_flux);
 
      virtual void
      regridInternals(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) = 0;
 
      virtual void
      regridSolvers(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel);
 
      virtual void
      resetDielectricCells(EBAMRIVData& a_data) const;
 
      virtual void
      sanityCheck() const;
 
      virtual void
      setupCdr();
 
      virtual void
      setupPoisson();
 
      virtual void
      setupRadiativeTransfer();
 
      virtual void
      setupSigma();
 
      virtual void
      setSolverVerbosity();
 
      virtual void
      solverDump();
 
      virtual void
      setVoltage(std::function<Real(const Real a_time)> a_voltage);
 
      virtual void
      solveRadiativeTransfer(const Real a_dt);
 
      virtual void
      setCdrSolvers(RefCountedPtr<CdrLayout<CdrSolver>>& a_cdr);
 
      virtual void
      setFieldSolver(RefCountedPtr<FieldSolver>& a_fieldSolver);
 
      virtual void
      setRadiativeTransferSolvers(RefCountedPtr<RtLayout<RtSolver>>& a_rte);
 
      virtual Real
      computeElectrodeCurrent();
 
      virtual Real
      computeDielectricCurrent();
 
      virtual Real
      computeDomainCurrent();
 
      virtual Real
      computeOhmicInductionCurrent();
 
      virtual Real
      computeRelaxationTime();
 
      virtual Real
      getDt();
 
    protected:
      enum class SourceTermComputation
      {
        Interpolated,
        InterpolatedStable,
        CellAverage,
        Upwind
      };
 
      enum class TimeCode
      {
        Advection,
        Diffusion,
        AdvectionDiffusion,
        Source,
        RelaxationTime,
        Restricted,
        Hardcap,
        Error,
        Physics
      };
 
      std::string m_realm;
 
      std::string m_className;
 
      phase::which_phase m_phase;
 
      SourceTermComputation m_whichSourceTermComputation;
 
      RefCountedPtr<MultiFluidIndexSpace> m_multifluidIndexSpace;
 
      RefCountedPtr<CdrPlasmaPhysics> m_physics;
 
      RefCountedPtr<CdrLayout<CdrSolver>> m_cdr;
 
      RefCountedPtr<RtLayout<RtSolver>> m_rte;
 
      RefCountedPtr<FieldSolver> m_fieldSolver;
 
      RefCountedPtr<SurfaceODESolver<1>> m_sigma;
 
      EBAMRCellData m_currentDensity;
 
      EBAMRCellData m_physicsPlotVars;
 
      std::function<Real(const Real a_time)> m_voltage;
 
      Real m_minDt;
 
      Real m_maxDt;
 
      Real m_cfl;
 
      Real m_relaxTime;
 
      Real m_time;
 
      Real m_dt;
 
      Real m_dtCFL;
 
      TimeCode m_timeCode;
 
      int m_solverVerbosity;
 
      int m_fastRTE;
 
      int m_fastPoisson;
 
      int m_upwindFactor;
 
      virtual void
      parseVerbosity();
 
      virtual void
      parseSolverVerbosity();
 
      virtual void
      parseCFL();
 
      virtual void
      parseRelaxationTime();
 
      virtual void
      parseMinDt();
 
      virtual void
      parseMaxDt();
 
      virtual void
      parseFastPoisson();
 
      virtual void
      parseFastRadiativeTransfer();
 
      virtual void
      parseSourceComputation();
 
      virtual void
      writeJ(LevelData<EBCellFAB>& a_output, int& a_comp, const std::string a_outputRealm, const int a_level) const;
 
      virtual void
      computePhysicsPlotVars(EBAMRCellData& a_physicsPlotVars) const 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;
    };
  } // namespace CdrPlasma
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif