CD_EddingtonSP1.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_EDDINGTONSP1_H
#define CD_EDDINGTONSP1_H
 
// Std includes
#include <random>
 
// Chombo includes
#include <AMRMultiGrid.H>
#include <AMRTGA.H>
#include <EBBackwardEuler.H>
#include <EBSimpleSolver.H>
#include <BiCGStabSolver.H>
#include <GMRESSolver.H>
 
// Our includes
#include <CD_RtSolver.H>
#include <CD_EBHelmholtzOpFactory.H>
#include <CD_EddingtonSP1DomainBc.H>
#include <CD_EllipticSolverChain.H>
#include <CD_NamespaceHeader.H>
 
class EddingtonSP1 : public RtSolver
{
public:
  static Real
  s_defaultDomainBcFunction(const RealVect& a_position, const Real a_time);
 
  EddingtonSP1();
 
  EddingtonSP1(const EddingtonSP1& a_other) = delete;
 
  EddingtonSP1(const EddingtonSP1&& a_other) = delete;
 
  virtual ~EddingtonSP1();
 
  EddingtonSP1&
  operator=(const EddingtonSP1& a_other) = delete;
 
  EddingtonSP1&
  operator=(const EddingtonSP1&& a_other) = delete;
 
  virtual bool
  advance(const Real a_dt, EBAMRCellData& a_phi, const EBAMRCellData& a_source, const bool a_zeroPhi = false) override;
 
  virtual void
  advanceEuler(EBAMRCellData& a_phi, const EBAMRCellData& a_source, const Real a_dt, const bool a_zeroPhi) noexcept;
 
  virtual void
  parseOptions() override;
 
  virtual void
  parseRuntimeOptions() override;
 
  virtual void
  setDomainSideBcFunction(const int                               a_dir,
                          const Side::LoHiSide                    a_side,
                          const EddingtonSP1DomainBc::BcFunction& a_function);
 
  virtual void
  allocate() override;
 
  virtual void
  preRegrid(const int a_base, const int a_oldFinestLevel) override;
 
  virtual void
  deallocate() override;
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
  virtual void
  registerOperators() override;
 
  virtual void
  computeBoundaryFlux(EBAMRIVData& a_ebFlux, const EBAMRCellData& a_phi) override;
 
  virtual void
  computeDomainFlux(EBAMRIFData& a_domainflux, const EBAMRCellData& a_data) override;
 
  virtual void
  computeFlux(EBAMRCellData& a_flux, const EBAMRCellData& a_phi) override;
 
  virtual void
  computeDensity(EBAMRCellData& a_isotropic, const EBAMRCellData& a_phi) override;
 
  virtual void
  writePlotFile() override;
 
#ifdef CH_USE_HDF5
  virtual void
  writeCheckpointLevel(HDF5Handle& a_handle, const int a_level) const override;
#endif
 
#ifdef CH_USE_HDF5
  virtual void
  readCheckpointLevel(HDF5Handle& a_handle, const int a_level) override;
#endif
 
protected:
  static constexpr Real m_alpha = 1.0;
 
  static constexpr Real m_beta = -1.0;
 
  enum class BottomSolverType
  {
    Simple,
    BiCGStab,
    GMRES,
  };
 
  enum class MultigridType
  {
    VCycle,
    WCycle,
  };
 
  enum class EBBCType
  {
    Dirichlet,
    Neumann,
    Larsen
  };
 
  EBHelmholtzOp::Smoother m_multigridRelaxMethod;
 
  int m_multigridChebyOrder;
 
  Real m_multigridChebyEigRatio;
 
  int m_multigridRasInnerSweeps;
 
  MultigridType m_multigridType;
 
  bool m_isSolverSetup;
 
  bool m_multigridRefluxFree;
 
  bool m_kappaScale;
 
  bool m_regridSlopes;
 
  int m_multigridVerbosity;
 
  int m_multigridPreSmooth;
 
  int m_multigridPostSmooth;
 
  int m_multigridBottomSmooth;
 
  int m_multigridMaxIterations;
 
  int m_multigridMinIterations;
 
  int m_multigridBcOrder;
 
  int m_multigridBcWeight;
 
  BottomSolverType m_bottomSolverType;
 
  int m_numSmoothingsForSimpleSolver;
 
  int m_minCellsBottom;
 
  Real m_multigridExitTolerance;
 
  Real m_multigridExitHang;
 
  Real m_reflectCoefOne;
 
  Real m_reflectCoefTwo;
 
  RefCountedPtr<AMRMultiGrid<LevelData<EBCellFAB>>> m_multigridSolver;
 
  BiCGStabSolver<LevelData<EBCellFAB>> m_bicgstab;
 
  GMRESSolver<LevelData<EBCellFAB>> m_gmres;
 
  RefCountedPtr<EBHelmholtzOpFactory> m_helmholtzOpFactory;
 
  EBSimpleSolver m_simpleSolver;
 
  EllipticSolverChain::Settings m_krylovSettings;
 
  EllipticSolverChain::FallbackPolicy m_fallbackPolicy;
 
  EllipticSolverChain::KrylovSolver<EBCellFAB> m_krylov;
 
  EBAMRCellData m_cacheSrc;
 
  EBAMRCellData m_resid;
 
  EBAMRCellData m_helmAco;
 
  EBAMRFluxData m_helmBco;
 
  EBAMRIVData m_helmBcoIrreg;
 
  EddingtonSP1DomainBc m_domainBc;
 
  std::map<EddingtonSP1DomainBc::DomainSide, EddingtonSP1DomainBc::BcFunction> m_domainBcFunctions;
 
  std::pair<EBBCType, Real> m_ebbc;
 
  virtual void
  setupSolver();
 
  virtual void
  setHelmholtzCoefficients();
 
  virtual void
  setHelmholtzCoefficientsBox(EBCellFAB&       a_helmAco,
                              EBFluxFAB&       a_helmBco,
                              BaseIVFAB<Real>& a_helmBcoIrreg,
                              const int        a_lvl,
                              const DataIndex& a_dit);
 
  virtual void
  setupHelmholtzFactory();
 
  virtual void
  setupMultigrid();
 
  virtual std::string
  makeBcString(const int a_dir, const Side::LoHiSide a_side) const;
 
  virtual EddingtonSP1DomainBc::BcType
  parseBcString(const std::string& a_str) const;
 
  virtual void
  parseDomainBC();
 
  virtual void
  parseEBBC();
 
  virtual void
  parseStationary();
 
  virtual void
  parsePlotVariables();
 
  virtual void
  parseMultigridSettings();
 
  virtual void
  parseKappaScale();
 
  virtual void
  parseReflection();
 
  virtual void
  parseRegridSlopes();
 
  virtual void
  setDefaultDomainBcFunctions();
};
 
#include <CD_NamespaceFooter.H>
 
#endif