CD_MFHelmholtzOp.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_MFHELMHOLTZOP_H
#define CD_MFHELMHOLTZOP_H
 
// Std includes
#include <map>
#include <chrono>
 
// Chombo includes
#include <MFCellFAB.H>
#include <MFFluxFAB.H>
 
// Our includes
#include <CD_Location.H>
#include <CD_MFMultigridInterpolator.H>
#include <CD_MFCoarAve.H>
#include <CD_MFReflux.H>
#include <CD_MFLevelGrid.H>
#include <CD_MFBaseIVFAB.H>
#include <CD_MFHelmholtzJumpBC.H>
#include <CD_EBHelmholtzOp.H>
#include <CD_MFHelmholtzDomainBCFactory.H>
#include <CD_MFHelmholtzEBBCFactory.H>
#include <CD_MFHelmholtzJumpBCFactory.H>
#include <CD_NamespaceHeader.H>
 
class MFHelmholtzOp : public LevelTGAHelmOp<LevelData<MFCellFAB>, MFFluxFAB>
{
public:
  enum class Smoother
  {
    PointJacobi,
    GauSaiRedBlack,
    GauSaiMultiColor,
    Chebyshev,
    RestrictedAdditiveSchwarz,
  };
 
  MFHelmholtzOp() = delete;
 
  MFHelmholtzOp(const MFHelmholtzOp& a_op) = delete;
 
  MFHelmholtzOp(const MFHelmholtzOp&& a_op) = delete;
 
  MFHelmholtzOp(const Location::Cell                             a_dataLocation,
                const MFLevelGrid&                               a_mflgFine,
                const MFLevelGrid&                               a_mflg,
                const MFLevelGrid&                               a_mflgCoFi,
                const MFLevelGrid&                               a_mflgCoar,
                const MFLevelGrid&                               a_mflgCoarMG,
                const MFMultigridInterpolator&                   a_interpolator,
                const MFReflux&                                  a_fluxReg,
                const MFCoarAve&                                 a_coarAve,
                const RefCountedPtr<LevelData<BaseFab<bool>>>&   a_validCells,
                const RefCountedPtr<MFHelmholtzDomainBCFactory>& a_domainBC,
                const RefCountedPtr<MFHelmholtzEBBCFactory>&     a_ebBC,
                const RefCountedPtr<MFHelmholtzJumpBCFactory>&   a_jumpBcFactory,
                const RealVect&                                  a_probLo,
                const Real&                                      a_dx,
                const int&                                       a_refToFine,
                const int&                                       a_refToCoar,
                const bool&                                      a_hasFine,
                const bool&                                      a_hasCoar,
                const bool&                                      a_hasMGObjects,
                const bool&                                      a_isMGOperator,
                const Real&                                      a_alpha,
                const Real&                                      a_beta,
                const RefCountedPtr<LevelData<MFCellFAB>>&       a_Acoef,
                const RefCountedPtr<LevelData<MFFluxFAB>>&       a_Bcoef,
                const RefCountedPtr<LevelData<MFBaseIVFAB>>&     a_BcoefIrreg,
                const IntVect&                                   a_ghostPhi,
                const IntVect&                                   a_ghostRhs,
                const int&                                       a_jumpOrder,
                const int&                                       a_jumpWeight,
                const int&                                       a_preCondSmooth,
                const Smoother&                                  a_relaxType,
                const Real&                                      a_relaxFactor,
                const int&                                       a_chebyOrder,
                const Real&                                      a_chebyEigRatio,
                const int&                                       a_rasInnerSweeps,
                const bool                                       a_refluxFree = false);
 
  virtual ~MFHelmholtzOp();
 
  MFHelmholtzOp&
  operator=(const MFHelmholtzOp& a_oper) = delete;
 
  MFHelmholtzOp&
  operator=(const MFHelmholtzOp&& a_oper) = delete;
 
  void
  setAcoAndBco(const RefCountedPtr<LevelData<MFCellFAB>>&   a_Acoef,
               const RefCountedPtr<LevelData<MFFluxFAB>>&   a_Bcoef,
               const RefCountedPtr<LevelData<MFBaseIVFAB>>& a_BcoefIrreg);
 
  const RefCountedPtr<LevelData<MFCellFAB>>&
  getAcoef();
 
  const RefCountedPtr<LevelData<MFFluxFAB>>&
  getBcoef();
 
  const RefCountedPtr<LevelData<MFBaseIVFAB>>&
  getBcoefIrreg();
 
  void
  setJump(RefCountedPtr<LevelData<BaseIVFAB<Real>>>& a_jump);
 
  RefCountedPtr<EBHelmholtzOp>&
  getHelmOp(const int a_phase);
 
  int
  refToCoarser() override final;
 
  void
  setAlphaAndBeta(const Real& a_alpha, const Real& a_beta) override final;
 
  void
  divideByIdentityCoef(LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  applyOpNoBoundary(LevelData<MFCellFAB>& a_ans, const LevelData<MFCellFAB>& a_phi) override final;
 
  void
  fillGrad(const LevelData<MFCellFAB>& a_phi) override final;
 
  void
  getFlux(MFFluxFAB&                  a_flux,
          const LevelData<MFCellFAB>& a_data,
          const Box&                  a_grid,
          const DataIndex&            a_dit,
          Real                        a_scale) override final;
 
  void
  residual(LevelData<MFCellFAB>&       a_residual,
           const LevelData<MFCellFAB>& a_phi,
           const LevelData<MFCellFAB>& a_rhs,
           const bool                  a_homogeneousPhysBc) override final;
 
  void
  preCond(LevelData<MFCellFAB>& a_corr, const LevelData<MFCellFAB>& a_residual) override final;
 
  void
  applyOp(LevelData<MFCellFAB>& a_Lphi, const LevelData<MFCellFAB>& a_phi, bool a_homogeneousPhysBc) override final;
 
  template <typename Duration = std::chrono::microseconds>
  Vector<long long>
  computeOperatorLoads(LevelData<MFCellFAB>& a_phi, const int a_numApply) noexcept;
 
  void
  relax(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_residual, int a_iterations) override final;
 
  void
  relaxPointJacobi(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_residual, const int a_iterations);
 
  void
  relaxGSRedBlack(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_residual, const int a_iterations);
 
  void
  relaxGSMultiColor(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_residual, const int a_iterations);
 
  void
  relaxChebyshev(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_residual, const int a_iterations);
 
  void
  relaxRestrictedAdditiveSchwarz(LevelData<MFCellFAB>&       a_correction,
                                 const LevelData<MFCellFAB>& a_residual,
                                 const int                   a_iterations);
 
  void
  create(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  createCoarser(LevelData<MFCellFAB>& a_coarse, const LevelData<MFCellFAB>& a_fine, bool a_ghosted) override final;
 
  void
  createCoarsened(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs, const int& a_refRat) override final;
 
  void
  incr(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs, Real a_scale) override final;
 
  Real
  dotProduct(const LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  dotProductMaskedLocal(Real&                           a_sumKappaXY,
                        Real&                           a_sumVolume,
                        const LevelData<MFCellFAB>&     a_lhs,
                        const LevelData<MFCellFAB>&     a_rhs,
                        const LevelData<BaseFab<bool>>& a_mask,
                        const bool                      a_needVolume) const noexcept;
 
  void
  scale(LevelData<MFCellFAB>& a_lhs, const Real& a_scale) override final;
 
  void
  setToZero(LevelData<MFCellFAB>& a_lhs) override final;
 
  void
  assign(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  assignCopier(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs, const Copier& a_copier) override final;
 
  void
  assignLocal(LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  buildCopier(Copier& a_copier, const LevelData<MFCellFAB>& a_lhs, const LevelData<MFCellFAB>& a_rhs) override;
 
  Real
  norm(const LevelData<MFCellFAB>& a_lhs, int a_order) override final;
 
  void
  axby(LevelData<MFCellFAB>&       a_lhs,
       const LevelData<MFCellFAB>& a_x,
       const LevelData<MFCellFAB>& a_y,
       const Real                  a_a,
       const Real                  a_b) override final;
 
  void
  restrictResidual(LevelData<MFCellFAB>&       a_resCoar,
                   LevelData<MFCellFAB>&       a_phi,
                   const LevelData<MFCellFAB>& a_rhs) override final;
 
  void
  prolongIncrement(LevelData<MFCellFAB>& a_phi, const LevelData<MFCellFAB>& a_correctCoarse) override final;
 
  void
  AMRUpdateResidual(LevelData<MFCellFAB>&       a_residual,
                    const LevelData<MFCellFAB>& a_correction,
                    const LevelData<MFCellFAB>& a_coarseCorrection) override final;
 
  void
  AMRRestrict(LevelData<MFCellFAB>&       a_residualCoarse,
              const LevelData<MFCellFAB>& a_residual,
              const LevelData<MFCellFAB>& a_correction,
              const LevelData<MFCellFAB>& a_coarseCorrection,
              bool                        a_skip_res) override final;
 
  void
  AMRProlong(LevelData<MFCellFAB>& a_correction, const LevelData<MFCellFAB>& a_coarseCorrection) override final;
 
  void
  AMRResidual(LevelData<MFCellFAB>&             a_residual,
              const LevelData<MFCellFAB>&       a_phiFine,
              const LevelData<MFCellFAB>&       a_phi,
              const LevelData<MFCellFAB>&       a_phiCoar,
              const LevelData<MFCellFAB>&       a_rhs,
              bool                              a_homogeneousPhysBC,
              AMRLevelOp<LevelData<MFCellFAB>>* a_finerOp) override final;
 
  void
  AMRResidualNF(LevelData<MFCellFAB>&       a_residual,
                const LevelData<MFCellFAB>& a_phi,
                const LevelData<MFCellFAB>& a_phiCoar,
                const LevelData<MFCellFAB>& a_rhs,
                bool                        a_homogeneousPhysBC) override final;
 
  void
  AMRResidualNC(LevelData<MFCellFAB>&             a_residual,
                const LevelData<MFCellFAB>&       a_phiFine,
                const LevelData<MFCellFAB>&       a_phi,
                const LevelData<MFCellFAB>&       a_rhs,
                bool                              a_homogeneousPhysBC,
                AMRLevelOp<LevelData<MFCellFAB>>* a_finerOp) override final;
 
  void
  AMROperatorNF(LevelData<MFCellFAB>&       a_Lphi,
                const LevelData<MFCellFAB>& a_phi,
                const LevelData<MFCellFAB>& a_phiCoar,
                bool                        a_homogeneousPhysBC) override final;
 
  void
  AMROperatorNC(LevelData<MFCellFAB>&             a_Lphi,
                const LevelData<MFCellFAB>&       a_phiFine,
                const LevelData<MFCellFAB>&       a_phi,
                bool                              a_homogeneousPhysBC,
                AMRLevelOp<LevelData<MFCellFAB>>* a_finerOp) override final;
 
protected:
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  Location::Cell m_dataLocation;
 
  Smoother m_smoother;
 
  Vector<IntVect> m_colors;
 
  std::map<int, RefCountedPtr<EBHelmholtzOp>> m_helmOps;
 
  RefCountedPtr<MFHelmholtzJumpBC> m_jumpBC;
 
  RefCountedPtr<LevelData<BaseIVFAB<Real>>> m_jump;
 
  RefCountedPtr<LevelData<BaseFab<bool>>> m_validCells;
 
  std::map<int, RefCountedPtr<LevelData<BaseIVFAB<Real>>>> m_dirichletBcValues;
 
  MFLevelGrid m_mflg;
 
  MFLevelGrid m_mflgFine;
 
  MFLevelGrid m_mflgCoar;
 
  MFLevelGrid m_mflgCoFi;
 
  MFLevelGrid m_mflgCoarMG;
 
  MFMultigridInterpolator m_interpolator;
 
  MFCoarAve m_coarAve;
 
  RefCountedPtr<LevelData<MFCellFAB>> m_Acoef;
 
  RefCountedPtr<LevelData<MFFluxFAB>> m_Bcoef;
 
  RefCountedPtr<LevelData<MFBaseIVFAB>> m_BcoefIrreg;
 
  Copier m_exchangeCopier;
 
  bool m_multifluid;
 
  bool m_hasMGObjects;
 
  int m_numSmoothPreCond;
 
  int m_numPhases;
 
  int m_refToCoar;
 
  IntVect m_ghostPhi;
 
  IntVect m_ghostRhs;
 
  bool m_hasCoar;
 
  bool m_hasFine;
 
  bool m_hasMGObjcts;
 
  void
  updateJumpBC(const LevelData<MFCellFAB>& a_phi, const bool a_homogeneousPhysBC);
 
  void
  exchangeGhost(const LevelData<MFCellFAB>& a_phi) const;
 
  void
  interpolateCF(const LevelData<MFCellFAB>& a_phi, const LevelData<MFCellFAB>* a_phiCoar, const bool a_homogeneousCF);
 
  void
  applyOp(LevelData<MFCellFAB>&             a_Lphi,
          const LevelData<MFCellFAB>&       a_phi,
          const LevelData<MFCellFAB>* const a_phiCoar,
          const bool                        a_homogeneousPhysBC,
          const bool                        a_homogeneousCFBC);
 
  void
  AMROperator(LevelData<MFCellFAB>&             a_Lphi,
              const LevelData<MFCellFAB>&       a_phiFine,
              const LevelData<MFCellFAB>&       a_phi,
              const LevelData<MFCellFAB>&       a_phiCoar,
              const bool                        a_homogeneousPhysBC,
              AMRLevelOp<LevelData<MFCellFAB>>* a_finerOp) override;
};
 
#include <CD_NamespaceFooter.H>
 
#include <CD_MFHelmholtzOpImplem.H>
 
#endif