CD_Realm.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_REALM_H
#define CD_REALM_H
 
// Std includes
#include <map>
#include <set>
 
// Our includes
#include <CD_PhaseRealm.H>
#include <CD_EBAMRParticleMesh.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_MFLevelGrid.H>
#include <CD_LevelTiles.H>
#include <CD_ParticleGhostMask.H>
#include <CD_PetscGrid.H>
#include <CD_NamespaceHeader.H>
 
using AMRMask = Vector<RefCountedPtr<LevelData<BaseFab<bool>>>>;
 
class Realm
{
public:
  const static std::string Primal;
 
  const static std::string primal;
 
  Realm();
 
  Realm(const Realm& a_other) = delete;
 
  Realm(const Realm&& a_other) = delete;
 
  Realm&
  operator=(const Realm& a_other) = delete;
 
  Realm&
  operator=(const Realm&& a_other) = delete;
 
  ~Realm();
 
  void
  define(const Vector<DisjointBoxLayout>&                           a_grids,
         const Vector<ProblemDomain>&                               a_domains,
         const Vector<int>&                                         a_refRat,
         const Vector<Real>&                                        a_dx,
         const RealVect&                                            a_probLo,
         const int                                                  a_finestLevel,
         const int                                                  a_minBlockSize,
         const int                                                  a_ebGhost,
         const int                                                  a_numGhost,
         const int                                                  a_lsfGhost,
         const int                                                  a_redistRad,
         const int                                                  a_mgInterpOrder,
         const int                                                  a_mgInterpRadius,
         const int                                                  a_mgInterpWeight,
         const CellCentroidInterpolation::Type                      a_centroidInterpType,
         const EBCentroidInterpolation::Type                        a_ebInterpType,
         const std::map<phase::which_phase, RefCountedPtr<BaseIF>>& a_baseif,
         const RefCountedPtr<MultiFluidIndexSpace>&                 a_mfis);
 
  void
  setGrids(const Vector<DisjointBoxLayout>& a_grids, const int a_finestLevel);
 
  void
  preRegrid();
 
  void
  regridBase(const int a_lmin);
 
  void
  regridOperators(const int a_lmin);
 
  void
  registerOperator(const std::string& a_operator, const phase::which_phase a_phase);
 
  bool
  queryOperator(const std::string& a_operator, const phase::which_phase a_phase) const;
 
  void
  registerMask(const std::string& a_mask, const int a_buffer);
 
  bool
  queryMask(const std::string& a_mask, const int a_buffer) const;
 
  const Vector<int>&
  getRefinementRatios() const;
 
  const Vector<Real>&
  getDx() const;
 
  const Vector<DisjointBoxLayout>&
  getGrids() const;
 
  const Vector<ProblemDomain>&
  getDomains() const;
 
  Vector<RefCountedPtr<MFLevelGrid>>&
  getMFLevelGrid();
 
  Vector<RefCountedPtr<MFLevelGrid>>&
  getMFLevelGridCoFi();
 
  Vector<RefCountedPtr<MFLevelGrid>>&
  getMFLevelGridFiCo();
 
  const RefCountedPtr<EBIndexSpace>&
  getEBIndexSpace(const phase::which_phase a_phase) const;
 
  const Vector<EBISLayout>&
  getEBISLayout(const phase::which_phase a_phase) const;
 
  const Vector<RefCountedPtr<EBLevelGrid>>&
  getEBLevelGrid(const phase::which_phase a_phase) const;
 
  const Vector<RefCountedPtr<EBLevelGrid>>&
  getEBLevelGridCoFi(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<VoFIterator>>>&
  getVofIterator(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<VoFIterator>>>&
  getMultiCutVofIterator(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIterator(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIteratorNoBoundary(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIteratorWithTangentialGhosts(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getMultiCutFaceIterator(const phase::which_phase a_phase) const;
 
  const Vector<RefCountedPtr<EBNonConservativeDivergence>>&
  getNonConservativeDivergence(const phase::which_phase a_phase) const;
 
  const Vector<RefCountedPtr<CellCentroidInterpolation>>&
  getCellCentroidInterpolation(const phase::which_phase a_phase) const;
 
  const Vector<RefCountedPtr<EBCentroidInterpolation>>&
  getEBCentroidInterpolation(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<EBCoarAve>>&
  getCoarseAverage(const phase::which_phase a_phase);
 
  Vector<RefCountedPtr<EBMultigridInterpolator>>&
  getMultigridInterpolator(const phase::which_phase a_phase);
 
  EBAMRParticleMesh&
  getParticleMesh(const phase::which_phase a_phase);
 
  EBAMRSurfaceDeposition&
  getSurfaceDeposition(const phase::which_phase a_phase);
 
  const Vector<RefCountedPtr<EBGradient>>&
  getGradientOp(const phase::which_phase a_phase) const;
 
  Vector<RefCountedPtr<EBGhostCellInterpolator>>&
  getGhostCellInterpolator(const phase::which_phase a_phase);
 
  Vector<RefCountedPtr<EBCoarseToFineInterp>>&
  getFineInterp(const phase::which_phase a_phase);
 
  Vector<RefCountedPtr<EBReflux>>&
  getFluxRegister(const phase::which_phase a_phase);
 
  Vector<RefCountedPtr<EBFluxRedistribution>>&
  getRedistributionOp(const phase::which_phase a_phase);
 
  const EBAMRFAB&
  getLevelset(const phase::which_phase a_phase) const;
 
  const EBAMRCellData&
  getRegularCells(const phase::which_phase a_phase) const;
 
  const EBAMRCellData&
  getCoveredCells(const phase::which_phase a_phase) const;
 
  const EBAMRCellData&
  getNotCoveredCells(const phase::which_phase a_phase) const;
 
  const EBAMRCellData&
  getIrregularCells(const phase::which_phase a_phase) const;
 
  const AMRMask&
  getMask(const std::string& a_mask, const int a_buffer) const;
 
  const AMRMask&
  getValidCells() const;
 
  void
  registerParticleGhostMask(const int a_width) noexcept;
 
  const AMRParticleGhostMask&
  getParticleGhostMask(const int a_width) const noexcept;
 
  const AMRParticleGhostMask&
  getParticleGhostMaskFineToCoar(const int a_width) const noexcept;
 
  const AMRParticleGhostMask&
  getParticleGhostMaskCoarToFine(const int a_width) const noexcept;
 
  const AMRParticleGhostMask&
  getTrivialParticleGhostMask() const noexcept;
 
  const AMRMask&
  getParticleGhostExposure(const int a_width) const noexcept;
 
  const Vector<RefCountedPtr<LevelTiles>>&
  getLevelTiles() const noexcept;
 
  LevelTiles::LevelAndBox
  getLevelAndBox(const RealVect& a_pos) const noexcept;
 
#ifdef CH_USE_PETSC
  const RefCountedPtr<PetscGrid>&
  getPetscGrid() const noexcept;
#endif
 
protected:
  bool m_isDefined;
 
  int m_verbosity;
 
  int m_finestLevel;
 
  int m_minBlockSize;
 
  int m_numGhost;
 
  RealVect m_probLo;
 
  Vector<Real> m_dx;
 
  Vector<int> m_refinementRatios;
 
  Vector<DisjointBoxLayout> m_grids;
 
  Vector<ProblemDomain> m_domains;
 
  Vector<RefCountedPtr<MFLevelGrid>> m_mflg;
 
  Vector<RefCountedPtr<MFLevelGrid>> m_mflgCoFi;
 
  Vector<RefCountedPtr<MFLevelGrid>> m_mflgFiCo;
 
  Vector<RefCountedPtr<LevelTiles>> m_levelTiles;
 
  RefCountedPtr<MultiFluidIndexSpace> m_multifluidIndexSpace;
 
  AMRMask m_validCells;
 
  std::set<int> m_particleGhostMaskWidths;
 
  std::map<int, AMRParticleGhostMask> m_particleGhostMask;
 
  std::map<int, AMRParticleGhostMask> m_particleGhostMaskFineToCoar;
 
  std::map<int, AMRParticleGhostMask> m_particleGhostMaskCoarToFine;
 
  std::map<int, AMRMask> m_particleGhostExposure;
 
#ifdef CH_USE_PETSC
  RefCountedPtr<PetscGrid> m_petscGrid;
#endif
 
  mutable std::map<phase::which_phase, RefCountedPtr<PhaseRealm>> m_realms;
 
  std::map<phase::which_phase, RefCountedPtr<BaseIF>> m_baseif;
 
  std::map<std::pair<std::string, int>, AMRMask> m_masks;
 
  void
  defineMFLevelGrid(const int a_lmin);
 
  void
  defineMasks(const int a_lmin);
 
  void
  defineOuterHaloMask(const int a_lmin);
 
  void
  defineOuterHaloMask(LevelData<BaseFab<bool>>& a_coarMask,
                      const ProblemDomain&      a_domainCoar,
                      const ProblemDomain&      a_domainFine,
                      const DisjointBoxLayout&  a_gridsCoar,
                      const DisjointBoxLayout&  a_gridsFine,
                      const int                 a_buffer,
                      const int                 a_refRat);
 
  void
  defineInnerHaloMask(const int a_lmin);
 
  void
  defineOuterCFMask(const int a_lmin);
 
  void
  defineOuterCFMask(LevelData<BaseFab<bool>>& a_coarMask,
                    const ProblemDomain&      a_domainCoar,
                    const ProblemDomain&      a_domainFine,
                    const DisjointBoxLayout&  a_gridsCoar,
                    const DisjointBoxLayout&  a_gridsFine,
                    const int                 a_buffer,
                    const int                 a_refRat);
 
  void
  defineInnerCFMask(const int a_lmin);
 
  void
  defineCFIVS(const int a_lmin);
 
  void
  defineValidCells();
 
  void
  defineLevelTiles() noexcept;
 
  void
  defineParticleGhostMasks() noexcept;
 
  void
  defineParticleGhostMaskSameLevel(LayoutData<ParticleGhostMask>& a_mask,
                                   const DisjointBoxLayout&       a_dbl,
                                   const ProblemDomain&           a_domain,
                                   const int                      a_ghost) noexcept;
 
  void
  defineParticleGhostMaskFineToCoar(LayoutData<ParticleGhostMask>& a_mask,
                                    const DisjointBoxLayout&       a_thisLayout,
                                    const DisjointBoxLayout&       a_coarLayout,
                                    const ProblemDomain&           a_coarDomain,
                                    const int                      a_refRat,
                                    const int                      a_ghost) noexcept;
 
  void
  defineParticleGhostMaskCoarToFine(LayoutData<ParticleGhostMask>&  a_mask,
                                    const DisjointBoxLayout&        a_thisLayout,
                                    const DisjointBoxLayout&        a_fineLayout,
                                    const LevelData<BaseFab<bool>>& a_validCells,
                                    const ProblemDomain&            a_fineDomain,
                                    const int                       a_refRat,
                                    const int                       a_ghost) noexcept;
 
  void
  defineParticleGhostExposure(LevelData<BaseFab<bool>>&            a_exposure,
                              const DisjointBoxLayout&             a_dbl,
                              const LayoutData<ParticleGhostMask>& a_same,
                              const LayoutData<ParticleGhostMask>& a_fineToCoar,
                              const LayoutData<ParticleGhostMask>& a_coarToFine,
                              const bool                           a_hasCoar,
                              const bool                           a_hasFine) noexcept;
 
  void
  definePetscGrid() noexcept;
 
  PhaseRealm&
  getRealm(const phase::which_phase a_phase);
};
 
#include <CD_NamespaceFooter.H>
 
#endif