CD_EBHelmholtzOpFactory.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_EBHELMHOLTZOPFACTORY_H
#define CD_EBHELMHOLTZOPFACTORY_H
 
// Chombo includes
#include <RealVect.H>
#include <EBLevelGrid.H>
#include <EBCellFAB.H>
#include <EBFluxFAB.H>
#include <BaseIVFAB.H>
#include <ConductivityBaseDomainBC.H>
#include <BaseEBBC.H>
 
// Our includes
#include <CD_Location.H>
#include <CD_EBCoarAve.H>
#include <CD_EBReflux.H>
#include <CD_EBMultigridInterpolator.H>
#include <CD_EBHelmholtzOp.H>
#include <CD_EBHelmholtzEBBCFactory.H>
#include <CD_EBHelmholtzDomainBCFactory.H>
#include <CD_NamespaceHeader.H>
 
class EBHelmholtzOpFactory : public AMRLevelOpFactory<LevelData<EBCellFAB>>
{
public:
  // Various alias for cutting down on typing.
 
  using Smoother = EBHelmholtzOp::Smoother;
 
  using AmrLevelGrids = Vector<RefCountedPtr<EBLevelGrid>>;
 
  using AmrMask = Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>;
 
  using AmrInterpolators = Vector<RefCountedPtr<EBMultigridInterpolator>>;
 
  using AmrFluxRegisters = Vector<RefCountedPtr<EBReflux>>;
 
  using AmrCoarseners = Vector<RefCountedPtr<EBCoarAve>>;
 
  using AmrCellData = Vector<RefCountedPtr<LevelData<EBCellFAB>>>;
 
  using AmrFluxData = Vector<RefCountedPtr<LevelData<EBFluxFAB>>>;
 
  using AmrIrreData = Vector<RefCountedPtr<LevelData<BaseIVFAB<Real>>>>;
 
  using AmrResolutions = Vector<Real>;
 
  using AmrRefRatios = Vector<int>;
 
  using DomainBCFactory = RefCountedPtr<EBHelmholtzDomainBCFactory>; // Will be replaced with better BC class...
 
  using EBBCFactory = RefCountedPtr<EBHelmholtzEBBCFactory>;
 
  EBHelmholtzOpFactory() = delete;
 
  EBHelmholtzOpFactory(const EBHelmholtzOpFactory& a_otherFactory) = delete;
 
  EBHelmholtzOpFactory(const EBHelmholtzOpFactory&& a_otherFactory) = delete;
 
  EBHelmholtzOpFactory(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 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_mgBlockingFactor,
                       const bool              a_refluxFree       = false,
                       const AmrLevelGrids&    a_deeperLevelGrids = AmrLevelGrids());
 
  ~EBHelmholtzOpFactory() override;
 
  void
  operator=(const EBHelmholtzOpFactory& a_opin) = delete;
 
  void
  operator=(const EBHelmholtzOpFactory&& a_opin) = delete;
 
  void
  coarsenCoefficientsMG();
 
  EBHelmholtzOp*
  MGnewOp(const ProblemDomain& a_fineDomain, int a_depth, bool a_homogeneousOnly = true) final;
 
  EBHelmholtzOp*
  AMRnewOp(const ProblemDomain& a_domain) final;
 
  int
  refToFiner(const ProblemDomain& a_domain) const final;
 
protected:
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  Location::Cell m_dataLocation;
 
  Smoother m_smoother;
 
  int m_chebyOrder;
 
  Real m_chebyEigRatio;
 
  int m_rasInnerSweeps;
 
  int m_numAmrLevels;
 
  IntVect m_ghostPhi;
 
  IntVect m_ghostRhs;
 
  Real m_alpha;
 
  Real m_beta;
 
  Real m_relaxFactor;
 
  bool m_refluxFree;
 
  RealVect m_probLo;
 
  // Things that pertain to AMR levels. The first entry corresponds to the coarsest AMR level.
 
  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;
 
  ProblemDomain m_bottomDomain;
 
  int m_mgBlockingFactor;
 
  AmrLevelGrids m_deeperLevelGrids;
 
  std::vector<bool> m_hasMgLevels;
 
  Vector<AmrLevelGrids> m_mgLevelGrids;
 
  Vector<AmrCellData> m_mgAcoef;
 
  Vector<AmrFluxData> m_mgBcoef;
 
  Vector<AmrIrreData> m_mgBcoefIrreg;
 
  void
  defineMultigridLevels();
 
  static bool
  isCoarser(const ProblemDomain& a_domainOne, const ProblemDomain& B);
 
  static bool
  isFiner(const ProblemDomain& a_domainOne, const ProblemDomain& B);
 
  bool
  getCoarserLayout(EBLevelGrid& a_coarEblg, const EBLevelGrid& a_fineEblg, int a_refRat, int a_blockingFactor) const;
 
  static void
  coarsenCoefficients(LevelData<EBCellFAB>&             a_coarAcoef,
                      LevelData<EBFluxFAB>&             a_coarBcoef,
                      LevelData<BaseIVFAB<Real>>&       a_coarBcoefIrreg,
                      const LevelData<EBCellFAB>&       a_fineAcoef,
                      const LevelData<EBFluxFAB>&       a_fineBcoef,
                      const LevelData<BaseIVFAB<Real>>& a_fineBcoefIrreg,
                      const EBLevelGrid&                a_eblgCoar,
                      const EBLevelGrid&                a_eblgFine,
                      int                               a_refRat);
 
  int
  findAmrLevel(const ProblemDomain& a_domain) const;
};
 
#include <CD_NamespaceFooter.H>
 
#endif