CD_DischargeInceptionStepper.H

Go to the documentation of this file.

/* chombo-discharge
 * Copyright © 2022 SINTEF Energy Research.
 * Copyright © 2022 NTNU.       
 * Copyright © 2022 Fanny Skirbekk.
 * Please refer to Copyright.txt and LICENSE in the chombo-discharge root directory.
 */
 
#ifndef CD_DischargeInceptionStepper_H
#define CD_DischargeInceptionStepper_H
 
// Our includes
#include <CD_TimeStepper.H>
#include <CD_TracerParticleSolver.H>
#include <CD_TracerParticle.H>
#include <CD_FieldSolver.H>
#include <CD_FieldSolverGMG.H>
#include <CD_CdrSolver.H>
#include <CD_CdrCTU.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace DischargeInception {
 
    enum class IntegrationAlgorithm
    {
      Euler,
      Trapezoidal
    };
 
    enum class TransportAlgorithm
    {
      Euler,
      Heun,
      ImExCTU
    };
 
    enum class Mode
    {
      Stationary,
      Transient
    };
 
    enum class TimeStepRestriction
    {
      Unknown,
      CDR,
      VoltageCurve,
      MinHardcap,
      MaxHardcap
    };
 
    template <typename P = TracerParticle<2, 3>, typename F = FieldSolverGMG, typename C = CdrCTU>
    class DischargeInceptionStepper : public TimeStepper
    {
    public:
      DischargeInceptionStepper();
 
      DischargeInceptionStepper(const DischargeInceptionStepper&) = delete;
 
      DischargeInceptionStepper(const DischargeInceptionStepper&&) = delete;
 
      virtual ~DischargeInceptionStepper();
 
      DischargeInceptionStepper&
      operator=(const DischargeInceptionStepper&) = delete;
 
      DischargeInceptionStepper&
      operator=(const DischargeInceptionStepper&&) = delete;
 
      void
      setupSolvers() override;
 
      void
      allocate() override;
 
      void
      initialData() override;
 
      void
      postInitialize() override;
 
      void
      postCheckpointSetup() override
      {}
 
      void
      registerRealms() override;
 
      void
      registerOperators() override;
 
      void
      parseOptions();
 
      void
      parseRuntimeOptions() 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 Vector<std::string>
      getStationaryPlotVariableNames() const noexcept;
 
      virtual Vector<std::string>
      getTransientPlotVariableNames() const noexcept;
 
      virtual Real
      computeDt() override;
 
      virtual Real
      advance(const Real a_dt) override;
 
      virtual void
      advanceIons(const Real a_dt) noexcept;
 
      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
      regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
      virtual void
      postRegrid() override;
 
      virtual void
      setVoltageCurve(const std::function<Real(const Real& a_time)>& a_voltageCurve) noexcept;
 
      virtual void
      setRho(const std::function<Real(const RealVect& x)>& a_rho) noexcept;
 
      virtual void
      setSigma(const std::function<Real(const RealVect& x)>& a_sigma) noexcept;
 
      virtual void
      setIonDensity(const std::function<Real(const RealVect x)>& a_density) noexcept;
 
      virtual void
      setIonMobility(const std::function<Real(const Real E)>& a_mobility) noexcept;
 
      virtual void
      setIonDiffusion(const std::function<Real(const Real E)>& a_diffCo) noexcept;
 
      virtual void
      setAlpha(const std::function<Real(const Real& E, const RealVect& x)>& a_alpha) noexcept;
 
      virtual void
      setEta(const std::function<Real(const Real& E, const RealVect& x)>& a_eta) noexcept;
 
      virtual const std::function<Real(const Real& E, const RealVect& x)>&
      getAlpha() const noexcept;
 
      virtual const std::function<Real(const Real& E, const RealVect& x)>&
      getEta() const noexcept;
 
      virtual void
      setBackgroundRate(const std::function<Real(const Real& E, const RealVect& x)>& a_backgroundRate) noexcept;
 
      virtual void
      setDetachmentRate(const std::function<Real(const Real& E, const RealVect& x)>& a_detachmentRate) noexcept;
 
      virtual void
      setFieldEmission(const std::function<Real(const Real& E, const RealVect& x)>& a_currentDensity) noexcept;
 
      virtual void
      setSecondaryEmission(const std::function<Real(const Real& E, const RealVect& x)>& a_coeff) noexcept;
 
      virtual Mode
      getMode() const noexcept;
 
      virtual const EBAMRCellData*
      getElectricField() const noexcept;
 
    protected:
      Mode m_mode;
 
      IntegrationAlgorithm m_inceptionAlgorithm;
 
      TransportAlgorithm m_transportAlgorithm;
 
      TimeStepRestriction m_timeStepRestriction;
 
      RefCountedPtr<TracerParticleSolver<P>> m_tracerParticleSolver;
 
      RefCountedPtr<FieldSolver> m_fieldSolver;
 
      RefCountedPtr<CdrSolver> m_ionSolver;
 
      mutable MFAMRCellData m_potential;
 
      MFAMRCellData m_potentialHomo;
 
      MFAMRCellData m_potentialInho;
 
      MFAMRCellData m_scratchHomo;
 
      MFAMRCellData m_scratchInho;
 
      mutable MFAMRCellData m_electricField;
 
      MFAMRCellData m_electricFieldHomo;
 
      MFAMRCellData m_electricFieldInho;
 
      EBAMRCellData m_homogeneousFieldGas;
 
      EBAMRCellData m_inceptionIntegral;
 
      Vector<EBAMRCellData> m_inceptionIntegralPlus;
 
      Vector<EBAMRCellData> m_inceptionIntegralMinu;
 
      Vector<EBAMRCellData> m_backgroundIonizationStationary;
 
      Vector<EBAMRCellData> m_detachmentStationary;
 
      Vector<EBAMRCellData> m_emissionRatesPlus;
 
      Vector<EBAMRCellData> m_emissionRatesMinu;
 
      Vector<EBAMRCellData> m_townsendCriterionPlus;
 
      Vector<EBAMRCellData> m_townsendCriterionMinu;
 
      EBAMRCellData m_emissionRate;
 
      EBAMRCellData m_inceptionVoltagePlus;
 
      EBAMRCellData m_inceptionVoltageMinu;
 
      EBAMRCellData m_streamerInceptionVoltagePlus;
 
      EBAMRCellData m_streamerInceptionVoltageMinu;
 
      EBAMRCellData m_townsendInceptionVoltagePlus;
 
      EBAMRCellData m_townsendInceptionVoltageMinu;
 
      EBAMRCellData m_townsendCriterion;
 
      EBAMRCellData m_detachment;
 
      EBAMRCellData m_backgroundIonization;
 
      EBAMRCellData m_gradAlpha;
 
      std::vector<std::tuple<Real, Real, RealVect>> m_KPlusValues;
 
      std::vector<std::tuple<Real, Real, RealVect>> m_KMinuValues;
 
      std::vector<std::tuple<Real, Real, RealVect>> m_TPlusValues;
 
      std::vector<std::tuple<Real, Real, RealVect>> m_TMinuValues;
 
      std::vector<std::pair<Real, Real>> m_maxK;
 
      std::vector<std::pair<Real, Real>> m_maxT;
 
      std::vector<Real> m_criticalVolumePlus;
 
      std::vector<Real> m_criticalVolumeMinu;
 
      std::vector<Real> m_criticalAreaPlus;
 
      std::vector<Real> m_criticalAreaMinu;
 
      std::vector<Real> m_ionizationVolume;
 
      std::vector<Real> m_RdotPlus;
 
      std::vector<Real> m_RdotMinu;
 
      std::vector<Real> m_voltageSweeps;
 
      std::vector<std::pair<Real, Real>> m_Rdot;
 
      std::vector<std::pair<Real, Real>> m_inceptionProbability;
 
      std::vector<std::pair<Real, Real>> m_criticalVolume;
 
      std::vector<std::pair<Real, Real>> m_criticalArea;
 
      std::vector<std::pair<Real, Real>> m_ionizationVolumeTransient;
 
      Real m_relativeDeltaU;
 
      Real m_deltaK;
 
      Real m_maxKLimit;
 
      Real m_cfl;
 
      Real m_firstDt;
 
      Real m_maxDt;
 
      Real m_minDt;
 
      Real m_epsVoltage;
 
      Real m_maxDtGrowth;
 
      Real m_minPhysDx;
 
      Real m_maxPhysDx;
 
      Real m_minGridDx;
 
      Real m_maxGridDx;
 
      Real m_alphaDx;
 
      Real m_townsendGridDx;
 
      Real m_gradAlphaDx;
 
      Real m_inceptionK;
 
      bool m_profile;
 
      bool m_debug;
 
      bool m_evaluateTownsend;
 
      bool m_fullIntegration;
 
      bool m_ionTransport;
 
      bool m_plotField;
 
      bool m_plotPoisson;
 
      bool m_plotTracer;
 
      bool m_plotNegativeIons;
 
      bool m_plotInceptionIntegral;
 
      bool m_plotInceptionVoltage;
 
      bool m_plotBackgroundIonization;
 
      bool m_plotDetachment;
 
      bool m_plotFieldEmission;
 
      bool m_plotAlpha;
 
      bool m_plotEta;
 
      bool m_plotTownsend;
 
      std::function<Real(const Real a_time)> m_voltageCurve;
 
      std::string m_realm;
 
      std::string m_dataOutputFile;
 
      std::string m_outputFile;
 
      phase::which_phase m_phase;
 
      std::function<Real(const RealVect& x)> m_rho;
 
      std::function<Real(const RealVect& x)> m_sigma;
 
      std::function<Real(const RealVect& x)> m_initialIonDensity;
 
      std::function<Real(const Real& E)> m_ionMobility;
 
      std::function<Real(const Real& E)> m_ionDiffusion;
 
      std::function<Real(const Real& E, const RealVect& x)> m_alpha;
 
      std::function<Real(const Real& E, const RealVect& x)> m_eta;
 
      std::function<Real(const Real& E, const RealVect& x)> m_detachmentRate;
 
      std::function<Real(const Real& E, const RealVect& x)> m_backgroundRate;
 
      std::function<Real(const Real& E, const RealVect& x)> m_fieldEmission;
 
      std::function<Real(const Real& E, const RealVect& x)> m_secondaryEmission;
 
      virtual void
      seedUniformParticles() noexcept;
 
      virtual void
      seedIonizationParticles(const Real a_voltage) noexcept;
 
      virtual void
      computeInceptionIntegral(EBAMRCellData& a_inceptionIntegral, const Real a_voltage) noexcept;
 
      virtual void
      computeInceptionIntegralStationary() noexcept;
 
      virtual void
      computeInceptionIntegralTransient(const Real& a_voltage) noexcept;
 
      virtual void
      inceptionIntegrateEuler(const Real& a_voltage) noexcept;
 
      virtual void
      inceptionIntegrateTrapezoidal(const Real& a_voltage) noexcept;
 
      virtual void
      interpolateGradAlphaToParticles() noexcept;
 
      virtual void
      computeTownsendCriterionStationary() noexcept;
 
      virtual void
      computeTownsendCriterionTransient(const Real& a_voltage) noexcept;
 
      virtual void
      townsendTrackEuler(const Real& a_voltage) noexcept;
 
      virtual void
      townsendTrackTrapezoidal(const Real& a_voltage) noexcept;
 
      virtual Real
      computeRdot(const Real& a_voltage) const noexcept;
 
      virtual void
      rewindTracerParticles() noexcept;
 
      virtual void
      resetTracerParticles() noexcept;
 
      virtual void
      computeBackgroundIonizationStationary() noexcept;
      virtual void
      computeDetachmentStationary() noexcept;
 
      virtual void
      computeFieldEmissionStationary() noexcept;
 
      virtual void
      computeFieldEmission(EBAMRCellData& a_emissionRate, const Real& a_voltage) const noexcept;
 
      virtual void
      evaluateFunction(EBAMRCellData&                                             a_data,
                       const Real&                                                a_voltage,
                       const std::function<Real(const Real E, const RealVect x)>& a_func) const noexcept;
 
      virtual void
      evaluateFunction(LevelData<EBCellFAB>&                                      a_data,
                       const Real&                                                a_voltage,
                       const std::function<Real(const Real E, const RealVect x)>& a_func,
                       const int                                                  a_level) const noexcept;
 
      virtual void
      computeInceptionVoltageVolume() noexcept;
 
      virtual std::pair<Real, RealVect>
      computeMinimumInceptionVoltage(const EBAMRCellData& a_Uinc) const noexcept;
 
      virtual void
      computeCriticalVolumeStationary() noexcept;
 
      virtual Real
      computeCriticalVolumeTransient() const noexcept;
 
      virtual void
      computeCriticalAreaStationary() noexcept;
 
      virtual Real
      computeCriticalAreaTransient() const noexcept;
 
      virtual void
      computeIonizationVolumeStationary() noexcept;
 
      virtual Real
      computeIonizationVolumeTransient(const Real& a_voltage) const noexcept;
 
      virtual void
      writeReportStationary() const noexcept;
 
      virtual void
      writeReportTransient() const noexcept;
 
      virtual void
      writePlotDataStationary(LevelData<EBCellFAB>& a_output,
                              int&                  a_icomp,
                              const std::string     a_outputRealm,
                              const int             a_level) const noexcept;
 
      virtual void
      writePlotDataTransient(LevelData<EBCellFAB>& a_output,
                             int&                  a_icomp,
                             const std::string     a_outputRealm,
                             const int             a_level) const noexcept;
 
      inline bool
      particleOutsideGrid(const RealVect& a_pos, const RealVect& a_probLo, const RealVect& a_probHi) const noexcept;
 
      inline bool
      particleInsideEB(const RealVect a_pos) const noexcept;
 
      inline void
      computeIonVelocity(const Real& a_voltage) noexcept;
 
      inline void
      computeIonDiffusion(const Real& a_voltage) noexcept;
 
      inline void
      parseMode() noexcept;
 
      inline void
      parseVoltages() noexcept;
 
      inline void
      parseOutput() noexcept;
 
      inline void
      parseVerbosity() noexcept;
 
      inline void
      parseInceptionAlgorithm() noexcept;
 
      inline void
      parseTransportAlgorithm() noexcept;
 
      inline void
      parsePlotVariables() noexcept;
 
      inline void
      solvePoisson() noexcept;
 
      inline void
      superposition(EBAMRCellData&       a_sumField,
                    const MFAMRCellData& a_inhomogeneousField,
                    const MFAMRCellData& a_homogeneousField,
                    const Real           a_voltage) const noexcept;
 
      inline void
      superposition(EBAMRCellData& a_sumField, const Real a_voltage) 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;
 
      virtual void
      getMaxValueAndLocation(Real& a_maxVal, RealVect& a_maxPos, const EBAMRCellData& a_data) const noexcept;
 
      virtual Real
      getCriticalField() const noexcept;
    };
  } // namespace DischargeInception
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#include <CD_DischargeInceptionStepperImplem.H>
 
#endif