CD_EBHelmholtzOpFactory.H

Go to the documentation of this file.

/* chombo-discharge
 * Copyright © 2021 SINTEF Energy Research.
 * Please refer to Copyright.txt and LICENSE in the chombo-discharge root directory.
 */
 
#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(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 IntVect&          a_ghostPhi,
                       const IntVect&          a_ghostRHS,
                       const Smoother&         a_relaxationMethod,
                       const Real&             a_relaxFactor,
                       const ProblemDomain&    a_bottomDomain,
                       const int&              a_mgBlockingFactor,
                       const AmrLevelGrids&    a_deeperLevelGrids = AmrLevelGrids());
 
  virtual ~EBHelmholtzOpFactory();
 
  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) override final;
 
  EBHelmholtzOp*
  AMRnewOp(const ProblemDomain& a_domain) override final;
 
  int
  refToFiner(const ProblemDomain& a_indexspace) const override final;
 
protected:
  static constexpr int m_comp = 0;
 
  static constexpr int m_nComp = 1;
 
  Location::Cell m_dataLocation;
 
  Smoother m_smoother;
 
  int m_numAmrLevels;
 
  IntVect m_ghostPhi;
 
  IntVect m_ghostRhs;
 
  Real m_alpha;
 
  Real m_beta;
 
  Real m_relaxFactor;
 
  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();
 
  bool
  isCoarser(const ProblemDomain& a_domainOne, const ProblemDomain& a_domainTwo) const;
 
  bool
  isFiner(const ProblemDomain& a_domainOne, const ProblemDomain& a_domainTwo) const;
 
  bool
  getCoarserLayout(EBLevelGrid&       a_coarseGrid,
                   const EBLevelGrid& a_fineGrid,
                   const int          a_refRat,
                   const int          a_blockingFactor) const;
 
  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,
                      const int                         a_refRat);
 
  int
  findAmrLevel(const ProblemDomain& a_domain) const;
};
 
#include <CD_NamespaceFooter.H>
 
#endif