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