CD_CdrPlasmaImExSdcStepper.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_CDRPLASMAIMEXSDCSTEPPER_H
#define CD_CDRPLASMAIMEXSDCSTEPPER_H
 
// Our includes
#include <CD_AmrMesh.H>
#include <CD_CdrPlasmaStepper.H>
#include <CD_CdrIterator.H>
#include <CD_RtIterator.H>
#include <CD_NamespaceHeader.H>
 
namespace Physics {
  namespace CdrPlasma {
 
    class CdrPlasmaImExSdcStepper : public CdrPlasmaStepper
    {
    public:
      class CdrStorage;
 
      class FieldStorage;
 
      class RtStorage;
 
      class SigmaStorage;
 
      CdrPlasmaImExSdcStepper() = delete;
 
      CdrPlasmaImExSdcStepper(RefCountedPtr<CdrPlasmaPhysics>& a_physics);
 
      virtual ~CdrPlasmaImExSdcStepper();
 
      Real
      advance(const Real a_dt) override;
 
      void
      allocateInternals() override;
 
      void
      deallocateInternals() override;
 
      void
      regridInternals(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
      void
      parseOptions() override;
 
      void
      parseRuntimeOptions() override;
 
    protected:
      Vector<RefCountedPtr<CdrStorage>> m_cdrScratch;
 
      Vector<RefCountedPtr<RtStorage>> m_rteScratch;
 
      RefCountedPtr<FieldStorage> m_fieldScratch;
 
      RefCountedPtr<SigmaStorage> m_sigmaScratch;
 
      int m_maxRetries;
 
      int m_p;
 
      int m_k;
 
      int m_errorNorm;
 
      int m_minCorr;
 
      int m_errorIdx;
 
      Real m_maxDtGrowth;
 
      Real m_minCFL;
 
      Real m_maxCFL;
 
      Real m_errThresh;
 
      Real m_safety;
 
      Real m_decreaseSafety;
 
      Real m_newDt;
 
      Real m_extrapDt;
 
      bool m_extrapAdvect;
 
      bool m_adaptiveDt;
 
      bool m_printReport;
 
      bool m_haveError;
 
      bool m_useTGA;
 
      bool m_doAdvectionSource;
 
      bool m_doDiffusion;
 
      bool m_doPoisson;
 
      bool m_doRTE;
 
      bool m_computeD;
 
      bool m_computeV;
 
      bool m_computeS;
 
      bool m_consistentE;
 
      bool m_consistentRTE;
 
      bool m_haveDtErr;
 
      bool m_profileSteps;
 
      Vector<Real> m_cdrError;
 
      Real m_sigmaError;
 
      Real m_maxError;
 
      Real m_preError;
 
      Vector<Vector<Real>> m_qmj;
 
      Vector<Vector<Real>> m_vandermonde;
 
      Vector<Real> m_nodes;
 
      Vector<Real> m_tm;
 
      Vector<Real> m_dtm;
 
      std::string m_whichNodes;
 
      RefCountedPtr<CdrStorage>&
      getCdrStorage(const CdrIterator<CdrSolver>& a_solverIt);
 
      RefCountedPtr<RtStorage>&
      getRtStorage(const RtIterator<RtSolver>& a_solverIt);
 
      void
      allocateCdrStorage();
 
      void
      allocateFieldStorage();
 
      void
      allocateRtStorage();
 
      void
      allocateSigmaStorage();
 
      Vector<EBAMRCellData*>
      getCdrSolversPhiK(const int a_m);
 
      EBAMRIVData&
      getSigmaSolverK(const int a_m);
 
      void
      setupQuadratureNodes(const int a_p);
 
      void
      setupUniformNodes(const int a_p);
 
      void
      setupLobattoNodes(const int a_p);
 
      void
      setupChebyshevNodes(const int a_p);
 
      void
      setupQmj(const int a_p);
 
      void
      setupSubintervals(const Real a_time, const Real a_dt);
 
      void
      quad(EBAMRCellData& a_quad, const Vector<EBAMRCellData>& a_integrand, const int a_m);
 
      void
      quad(EBAMRIVData& a_quad, const Vector<EBAMRIVData>& a_integrand, const int a_m);
 
      void
      copyCdrToPhiM0();
 
      void
      copySigmaToM0();
 
      void
      copyPhiPToCdr();
 
      void
      copySigmaPToSigma();
 
      void
      integrateRtTransient(const Real a_dt);
 
      void
      integrateRtStationary();
 
      void
      integrate(const Real a_dt, const Real a_time, const bool a_lagged_terms);
 
      void
      integrateAdvectionReaction(const Real a_dt, const int a_m, const bool a_lagged_terms);
 
      void
      integrateAdvection(const Real a_dt, const int a_m, const bool a_lagged_terms);
 
      void
      integrateDiffusion(const Real a_dt, const int a_m, const bool a_lagged_terms);
 
      Vector<EBAMRCellData*>
      getCdrErrors();
 
      void
      reconcileIntegrands();
 
      void
      computeFD0();
 
      void
      initializeErrors();
 
      void
      finalizeErrors();
 
      void
      computeNewDt(bool& a_accept_step, const Real a_dt, const int a_num_corrections);
 
      void
      adaptiveReport(const Real a_first_dt,
                     const Real a_dt,
                     const Real a_new_dt,
                     const int  a_corr,
                     const int  a_rej,
                     const Real a_max_err);
 
      void
      updateField();
 
      void
      updateField(const Vector<EBAMRCellData*>& a_densities, const EBAMRIVData& a_sigma);
 
      void
      updateDiffusionCoefficients();
 
      void
      storeSolvers();
 
      void
      restoreSolvers();
 
      void
      computeReactionNetwork(const int a_m, const Real a_time, const Real a_dt);
 
      void
      computeElectricFieldIntoScratch();
 
      void
      computeCdrEbStates();
 
      void
      computeCdrEbStates(const Vector<EBAMRCellData*>& a_phis);
 
      void
      computeCdrDomainStates();
 
      void
      computeCdrDomainStates(const Vector<EBAMRCellData*>& a_phis);
 
      void
      computeCdrGradients();
 
      void
      computeCdrGradients(const Vector<EBAMRCellData*>& a_phis);
 
      void
      computeCdrFluxes(const Real a_time);
 
      void
      computeCdrFluxes(const Vector<EBAMRCellData*>& a_phis, const Real a_time);
 
      void
      computeCdrDomainFluxes(const Real a_time);
 
      void
      computeCdrDomainFluxes(const Vector<EBAMRCellData*>& a_phis, const Real a_time);
 
      void
      computeCdrVelo(const Real a_time);
 
      void
      computeCdrVelo(const Vector<EBAMRCellData*>& a_phis, const Real a_time);
 
      Real
      computeDt() override;
 
      void
      computeSigmaFlux();
 
      Real
      getMaxError();
 
      Real
      getMaxNodeDistance();
 
      void
      writeStepProfile(const Real a_dt,
                       const Real a_error,
                       const int  a_substeps,
                       const int  a_corrections,
                       const int  a_rejections);
 
      void
      parseNodes();
 
      void
      parseDiffusionCoupling();
 
      void
      parseAdaptiveOptions();
 
      void
      parseDebugOptions();
 
      void
      parseAdvectionOptions();
    };
  } // namespace CdrPlasma
} // namespace Physics
 
#include <CD_NamespaceFooter.H>
 
#endif