CD_FieldSolverGMG.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_FIELDSOLVERGMG_H
#define CD_FIELDSOLVERGMG_H
 
// Chombo includes
#include <AMRMultiGrid.H>
#include <BiCGStabSolver.H>
#include <MFSimpleSolver.H>
#include <GMRESSolver.H>
 
// Our includes
#include <CD_FieldSolver.H>
#include <CD_MFHelmholtzOpFactory.H>
#include <CD_NamespaceHeader.H>
 
class FieldSolverGMG : public FieldSolver
{
public:
  FieldSolverGMG();
 
  FieldSolverGMG(const FieldSolverGMG& a_other) = delete;
 
  FieldSolverGMG(const FieldSolverGMG&& a_other) = delete;
 
  FieldSolverGMG&
  operator=(const FieldSolverGMG& a_other) = delete;
 
  FieldSolverGMG&
  operator=(const FieldSolverGMG&& a_other) = delete;
 
  virtual ~FieldSolverGMG();
 
  virtual bool
  solve(MFAMRCellData&       a_phi,
        const MFAMRCellData& a_rho,
        const EBAMRIVData&   a_sigma,
        const bool           a_zeroPhi = false) override;
 
  virtual void
  parseOptions() override;
 
  virtual void
  parseRuntimeOptions() override;
 
  virtual void
  computeElectricField(MFAMRCellData& a_E, const MFAMRCellData& a_potential) const override;
 
  virtual void
  computeElectricField(MFAMRFluxData& a_E, const MFAMRCellData& a_potential) const override;
 
  virtual void
  computeElectricField(EBAMRCellData&           a_E,
                       const phase::which_phase a_phase,
                       const MFAMRCellData&     a_potential) const override;
 
  virtual void
  computeElectricField(EBAMRFluxData&           a_E,
                       const phase::which_phase a_phase,
                       const MFAMRCellData&     a_potential) const override;
 
  virtual void
  preRegrid(const int a_lbase, const int a_oldFinestLevel) override;
 
  virtual void
  regrid(const int a_lmin, const int a_oldFinestLevel, const int a_newFinestLevel) override;
 
  virtual void
  registerOperators() override;
 
  virtual void
  setupSolver() override;
 
  virtual void
  setSolverPermittivities(const MFAMRCellData& a_permittivityCell,
                          const MFAMRFluxData& a_permittivityFace,
                          const MFAMRIVData&   a_permittivityEB) override;
 
  virtual Vector<long long>
  computeLoads(const DisjointBoxLayout& a_dbl, const int a_level) override;
 
protected:
  static constexpr Real m_alpha = 0.0;
 
  static constexpr Real m_beta = -1.0;
 
  enum class BottomSolverType
  {
    Simple,
    BiCGStab,
    GMRES
  };
 
  enum class MultigridType
  {
    VCycle,
    WCycle,
  };
 
  enum class JumpBCType
  {
    Natural,
    SaturationCharge,
  };
 
  MFHelmholtzOp::Smoother m_multigridRelaxMethod;
 
  MultigridType m_multigridType;
 
  BottomSolverType m_bottomSolverType;
 
  JumpBCType m_jumpBcType;
 
  bool m_kappaSource;
 
  bool m_isSolverSetup;
 
  bool m_multigridDropOrder;
 
  bool m_multigridUseDefaultSettings;
 
  int m_multigridVerbosity;
 
  int m_multigridBottomSolverVerbosity;
 
  int m_multigridSmooth;
 
  int m_multigridPreSmooth;
 
  int m_multigridPostSmooth;
 
  int m_multigridBottomSmooth;
 
  int m_multigridMaxIterations;
 
  int m_multigridMinIterations;
 
  int m_numSmoothingsForSimpleSolver;
 
  int m_minCellsBottom;
 
  int m_domainDropOrder;
 
  int m_multigridBcOrder;
 
  int m_multigridBcWeight;
 
  int m_multigridJumpOrder;
 
  int m_multigridJumpWeight;
 
  int m_multigridPreCondSmooth;
 
  Real m_multigridExitTolerance;
 
  Real m_multigridExitHang;
 
  Real m_multigridRelaxFactor;
 
  RefCountedPtr<MFHelmholtzOpFactory> m_helmholtzOpFactory;
 
  RefCountedPtr<AMRMultiGrid<LevelData<MFCellFAB>>> m_multigridSolver;
 
  BiCGStabSolver<LevelData<MFCellFAB>> m_bicgstab;
 
  GMRESSolver<LevelData<MFCellFAB>> m_gmres;
 
  MFSimpleSolver m_mfsolver;
 
  virtual void
  parseMultigridSettings();
 
  virtual void
  parseKappaSource();
 
  virtual void
  parseJumpBC();
 
  virtual void
  setPermittivities() override;
 
  virtual void
  setupHelmholtzFactory();
 
  virtual void
  setupMultigrid();
};
 
#include <CD_NamespaceFooter.H>
 
#endif