CD_MFHelmholtzOpFactory.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_MFHELMHOLTZOPFACTORY_H
#define CD_MFHELMHOLTZOPFACTORY_H
 
// Chombo includes
#include <MFCellFAB.H>
#include <MFFluxFAB.H>
 
// Our includes
#include <CD_MultiFluidIndexSpace.H>
#include <CD_Location.H>
#include <CD_EBAMRData.H>
#include <CD_MFHelmholtzOp.H>
#include <CD_MFCoarAve.H>
#include <CD_MFReflux.H>
#include <CD_MFMultigridInterpolator.H>
#include <CD_MFLevelGrid.H>
#include <CD_MFBaseIVFAB.H>
#include <CD_MFHelmholtzEBBCFactory.H>
#include <CD_MFHelmholtzJumpBCFactory.H>
#include <CD_NamespaceHeader.H>
 
class MFHelmholtzOpFactory : public AMRLevelOpFactory<LevelData<MFCellFAB>>
{
public:
  // Various alias for cutting down on typing.
 
  using MFIS = RefCountedPtr<MultiFluidIndexSpace>;
 
  using AmrLevelGrids = Vector<MFLevelGrid>;
 
  using AmrInterpolators = Vector<MFMultigridInterpolator>;
 
  using AmrFluxRegisters = Vector<MFReflux>;
 
  using AmrCoarseners = Vector<MFCoarAve>;
 
  using AmrResolutions = Vector<Real>;
 
  using AmrRefRatios = Vector<int>;
 
  using AmrMask = Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>;
 
  using AmrCellData = Vector<RefCountedPtr<LevelData<MFCellFAB>>>;
 
  using AmrFluxData = Vector<RefCountedPtr<LevelData<MFFluxFAB>>>;
 
  using AmrIrreData = Vector<RefCountedPtr<LevelData<MFBaseIVFAB>>>;
 
  using DomainBCFactory = RefCountedPtr<MFHelmholtzDomainBCFactory>;
 
  using EBBCFactory = RefCountedPtr<MFHelmholtzEBBCFactory>;
 
  using JumpBCFactory = RefCountedPtr<MFHelmholtzJumpBCFactory>;
 
  using Smoother = MFHelmholtzOp::Smoother;
 
  MFHelmholtzOpFactory() = delete;
 
  MFHelmholtzOpFactory(const MFHelmholtzOpFactory& a_otherFactory) = delete;
 
  MFHelmholtzOpFactory(const MFIS&             a_mfis,
                       const Location::Cell    a_dataLocation,
                       const Real&             a_alpha,
                       const Real&             a_beta,
                       const RealVect&         a_probLo,
                       const AmrLevelGrids&    a_amrLevelGrids,
                       const AmrMask&          a_validCells,
                       const AmrInterpolators& a_amrInterpolators,
                       const AmrFluxRegisters& a_amrFluxRegisters,
                       const AmrCoarseners&    a_amrCoarseners,
                       const AmrRefRatios&     a_amrRefRatios,
                       const AmrResolutions&   a_amrResolutions,
                       const AmrCellData&      a_amrAcoef,
                       const AmrFluxData&      a_amrBcoef,
                       const AmrIrreData&      a_amrBcoefIrreg,
                       const DomainBCFactory&  a_domainBcFactory,
                       const EBBCFactory&      a_ebBcFactory,
                       const JumpBCFactory&    a_jumpBcFactory,
                       const IntVect&          a_ghostPhi,
                       const IntVect&          a_ghostRhs,
                       const Smoother&         a_smoother,
                       const Real&             a_relaxFactor,
                       const int&              a_chebyOrder,
                       const Real&             a_chebyEigRatio,
                       const int&              a_rasInnerSweeps,
                       const ProblemDomain&    a_bottomDomain,
                       const int&              a_jumpOrder,
                       const int&              a_jumpWeight,
                       const int&              a_preCondSmooth,
                       const int&              a_blockingFactor,
                       const bool              a_refluxFree       = false,
                       const AmrLevelGrids&    a_deeperLevelGrids = AmrLevelGrids());
 
  virtual ~MFHelmholtzOpFactory();
 
  void
  setJump(const EBAMRIVData& a_sigma, const Real& a_scale);
 
  void
  setJump(const Real& a_sigma, const Real& a_scale);
 
  const EBAMRIVData&
  getSigma() const;
 
  void
  coarsenCoefficientsMG();
 
  MFHelmholtzOp*
  MGnewOp(const ProblemDomain& a_fineDomain, int a_depth, bool a_homogeneousOnly = true) override final;
 
  MFHelmholtzOp*
  AMRnewOp(const ProblemDomain& a_domain) override final;
 
  int
  refToFiner(const ProblemDomain& a_domain) const override final;
 
protected:
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  static constexpr int m_mainPhase = 0;
 
  MFIS m_mfis;
 
  Location::Cell m_dataLocation;
 
  Smoother m_smoother;
 
  int m_chebyOrder;
 
  Real m_chebyEigRatio;
 
  int m_rasInnerSweeps;
 
  int m_numAmrLevels;
 
  int m_numPreCondSmooth;
 
  IntVect m_ghostPhi;
 
  IntVect m_ghostRhs;
 
  Real m_alpha;
 
  Real m_beta;
 
  Real m_relaxFactor;
 
  bool m_refluxFree;
 
  RealVect m_probLo;
 
  AmrLevelGrids m_amrLevelGrids;
 
  AmrMask m_validCells;
 
  AmrInterpolators m_amrInterpolators;
 
  AmrFluxRegisters m_amrFluxRegisters;
 
  AmrCoarseners m_amrCoarseners;
 
  AmrRefRatios m_amrRefRatios;
 
  AmrResolutions m_amrResolutions;
 
  AmrCellData m_amrAcoef;
 
  AmrFluxData m_amrBcoef;
 
  AmrIrreData m_amrBcoefIrreg;
 
  DomainBCFactory m_domainBcFactory;
 
  EBBCFactory m_ebBcFactory;
 
  JumpBCFactory m_jumpBcFactory;
 
  EBAMRIVData m_amrJump;
 
  ProblemDomain m_bottomDomain;
 
  int m_mgBlockingFactor;
 
  int m_jumpOrder;
 
  int m_jumpWeight;
 
  AmrLevelGrids m_deeperLevelGrids;
 
  std::vector<bool> m_hasMgLevels;
 
  Vector<AmrLevelGrids> m_mgLevelGrids;
 
  Vector<AmrCellData> m_mgAcoef;
 
  Vector<AmrFluxData> m_mgBcoef;
 
  Vector<AmrIrreData> m_mgBcoefIrreg;
 
  Vector<EBAMRIVData> m_mgJump;
 
  Vector<Vector<RefCountedPtr<EBCoarAve>>> m_mgAveOp;
 
  void
  defineMultigridLevels();
 
  void
  defineJump();
 
  static bool
  isCoarser(const ProblemDomain& a_domainOne, const ProblemDomain& B);
 
  static bool
  isFiner(const ProblemDomain& a_domainOne, const ProblemDomain& B);
 
  bool
  getCoarserLayout(MFLevelGrid&       a_coarMflg,
                   const MFLevelGrid& a_fineMflg,
                   const int          a_refRat,
                   const int          a_blockingFactor) const;
 
  static void
  coarsenCoefficients(LevelData<MFCellFAB>&         a_coarAcoef,
                      LevelData<MFFluxFAB>&         a_coarBcoef,
                      LevelData<MFBaseIVFAB>&       a_coarBcoefIrreg,
                      const LevelData<MFCellFAB>&   a_fineAcoef,
                      const LevelData<MFFluxFAB>&   a_fineBcoef,
                      const LevelData<MFBaseIVFAB>& a_fineBcoefIrreg,
                      const MFLevelGrid&            a_mflgCoar,
                      const MFLevelGrid&            a_mflgFine,
                      const int                     a_refRat);
 
  int
  findAmrLevel(const ProblemDomain& a_domain) const;
};
 
#include <CD_NamespaceFooter.H>
 
#endif