CD_PhaseRealm.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_PHASEREALM_H
#define CD_PHASEREALM_H
 
// Std includes
#include <array>
 
// Chombo includes
#include <DisjointBoxLayout.H>
#include <ProblemDomain.H>
 
// Our includes
#include <CD_ComputationalGeometry.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_LoadBalancing.H>
#include <CD_MFLevelGrid.H>
#include <CD_EBCoarAve.H>
#include <CD_EBReflux.H>
#include <CD_DomainFluxIFFAB.H>
#include <CD_DomainFluxIFFABFactory.H>
#include <CD_EBMultigridInterpolator.H>
#include <CD_EBGradient.H>
#include <CD_EBFluxRedistribution.H>
#include <CD_EBAMRParticleMesh.H>
#include <CD_EBAMRSurfaceDeposition.H>
#include <CD_EBCoarseToFineInterp.H>
#include <CD_EBGhostCellInterpolator.H>
#include <CD_EBNonConservativeDivergence.H>
#include <CD_CellCentroidInterpolation.H>
#include <CD_EBCentroidInterpolation.H>
#include <CD_NamespaceHeader.H>
 
// These are operators that can be defined.
static const std::string s_outer_cf_region     = "outer_cf_region";     // Outside coarse-fine region
static const std::string s_inner_cf_region     = "inner_cf_region";     // Inside coarse-fine region
static const std::string s_outer_particle_halo = "outer_particle_halo"; // Outside particle halo region
static const std::string s_inner_particle_halo = "inner_particle_halo"; // Inside particle halo region
static const std::string s_cfivs               = "cfivs";               // Coarse-fine interface
static const std::string s_eb_gradient         = "eb_gradient";         // For computing gradients
static const std::string s_eb_irreg_interp     = "eb_irreg_interp";     // For data recentering
static const std::string s_eb_coar_ave         = "eb_coar_ave";         // For coarsening
static const std::string s_eb_fill_patch       = "eb_fill_patch";       // For regridding data
static const std::string s_eb_fine_interp      = "eb_fine_interp";      // For linearly filling ghost cells
static const std::string s_eb_flux_reg         = "eb_flux_reg";         // For flux registration
static const std::string s_eb_redist           = "eb_redist";           // For redistribution
static const std::string s_noncons_div         = "eb_non_cons_div";     // For computing non-conservative divergences
static const std::string s_eb_multigrid        = "eb_multigrid";        // For multigrid interpolation
static const std::string s_levelset            = "levelset";            // For putting level-set on mesh
static const std::string s_particle_mesh       = "particle_mesh";       // For doing particle-mesh operations.
 
class PhaseRealm
{
public:
  PhaseRealm();
 
  PhaseRealm(const PhaseRealm& a_other) = delete;
 
  PhaseRealm(const PhaseRealm&& a_other) = delete;
 
  PhaseRealm&
  operator=(const PhaseRealm& a_other) = delete;
 
  PhaseRealm&
  operator=(const PhaseRealm&& a_other) = delete;
 
  virtual ~PhaseRealm();
 
  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_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_centroidStencil,
         const EBCentroidInterpolation::Type   a_ebStencil,
         const RefCountedPtr<BaseIF>&          a_baseif,
         const RefCountedPtr<EBIndexSpace>&    a_ebis);
 
  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);
 
  bool
  queryOperator(const std::string& a_operator) const;
 
  const RefCountedPtr<EBIndexSpace>&
  getEBIndexSpace() const;
 
  const Vector<int>&
  getRefinementRatios() const;
 
  const Vector<Real>&
  getDx() const;
 
  const Vector<DisjointBoxLayout>&
  getGrids() const;
 
  const Vector<ProblemDomain>&
  getDomains() const;
 
  const Vector<EBISLayout>&
  getEBISLayout() const;
 
  const Vector<RefCountedPtr<EBLevelGrid>>&
  getEBLevelGrid() const;
 
  const Vector<RefCountedPtr<EBLevelGrid>>&
  getEBLevelGridCoFi() const;
 
  const Vector<RefCountedPtr<EBLevelGrid>>&
  getEBLevelGridFiCo() const;
 
  Vector<RefCountedPtr<LayoutData<VoFIterator>>>&
  getVofIterator() const;
 
  Vector<RefCountedPtr<LayoutData<VoFIterator>>>&
  getMultiCutVofIterator() const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIterator() const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIteratorNoBoundary() const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getFaceIteratorWithTangentialGhosts() const;
 
  Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>>&
  getMultiCutFaceIterator() const;
 
  const Vector<RefCountedPtr<CellCentroidInterpolation>>&
  getCellCentroidInterpolation() const;
 
  const Vector<RefCountedPtr<EBCentroidInterpolation>>&
  getEBCentroidInterpolation() const;
 
  const Vector<RefCountedPtr<EBNonConservativeDivergence>>&
  getNonConservativeDivergence() const;
 
  const Vector<RefCountedPtr<EBGradient>>&
  getGradientOp() const;
 
  EBAMRParticleMesh&
  getParticleMesh() const;
 
  EBAMRSurfaceDeposition&
  getSurfaceDeposition() const;
 
  Vector<RefCountedPtr<EBCoarAve>>&
  getCoarseAverage() const;
 
  Vector<RefCountedPtr<EBCoarseFineParticleMesh>>&
  getEBCoarseFineParticleMesh() const;
 
  Vector<RefCountedPtr<EBMultigridInterpolator>>&
  getMultigridInterpolator() const;
 
  Vector<RefCountedPtr<EBGhostCellInterpolator>>&
  getGhostCellInterpolator() const;
 
  Vector<RefCountedPtr<EBCoarseToFineInterp>>&
  getFineInterp() const;
 
  Vector<RefCountedPtr<EBReflux>>&
  getFluxRegister() const;
 
  Vector<RefCountedPtr<EBFluxRedistribution>>&
  getRedistributionOp() const;
 
  const EBAMRFAB&
  getLevelset() const;
 
  const EBAMRCellData&
  getRegularCells() const;
 
  const EBAMRCellData&
  getCoveredCells() const;
 
  const EBAMRCellData&
  getNotCoveredCells() const;
 
  const EBAMRCellData&
  getIrregularCells() const;
 
protected:
  bool m_isDefined;
 
  bool m_hasEbCf;
 
  bool m_profile;
 
  bool m_verbose;
 
  int m_finestLevel;
 
  int m_numGhostCells;
 
  int m_numEbGhostsCells;
 
  int m_numLsfGhostCells;
 
  int m_redistributionRadius;
 
  int m_multigridInterpolationOrder;
 
  int m_multigridInterpolationRadius;
 
  int m_multigridInterpolationWeight;
 
  RealVect m_probLo;
 
  CellCentroidInterpolation::Type m_cellCentroidInterpolationType;
 
  EBCentroidInterpolation::Type m_ebCentroidInterpolationType;
 
  Vector<Real> m_dx;
 
  Vector<int> m_refinementRatios;
 
  RefCountedPtr<EBIndexSpace> m_ebis;
 
  RefCountedPtr<BaseIF> m_baseif;
 
  std::map<std::string, bool> m_operatorMap;
 
  Vector<DisjointBoxLayout> m_grids;
 
  Vector<ProblemDomain> m_domains;
 
  Vector<EBISLayout> m_ebisl;
 
  Vector<RefCountedPtr<EBLevelGrid>> m_eblg;
 
  Vector<RefCountedPtr<EBLevelGrid>> m_eblgCoFi;
 
  Vector<RefCountedPtr<EBLevelGrid>> m_eblgFiCo;
 
  EBAMRFAB m_levelset;
 
  EBAMRCellData m_regularCells;
 
  EBAMRCellData m_coveredCells;
 
  EBAMRCellData m_notCoveredCells;
 
  EBAMRCellData m_irregularCells;
 
  mutable Vector<RefCountedPtr<LayoutData<VoFIterator>>> m_vofIter;
 
  mutable Vector<RefCountedPtr<LayoutData<VoFIterator>>> m_multiCutVofIter;
 
  mutable Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>> m_faceIter;
 
  mutable Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>> m_faceIterNoBoundary;
 
  mutable Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>> m_faceIterTanGhost;
 
  mutable Vector<RefCountedPtr<LayoutData<std::array<FaceIterator, SpaceDim>>>> m_multiCutFaceIter;
 
  mutable Vector<RefCountedPtr<EBCoarAve>> m_coarAve;
 
  mutable Vector<RefCountedPtr<EBMultigridInterpolator>> m_multigridInterpolator;
 
  mutable Vector<RefCountedPtr<EBGhostCellInterpolator>> m_ghostCellInterpolator;
 
  mutable Vector<RefCountedPtr<EBCoarseToFineInterp>> m_ebFineInterp;
 
  mutable Vector<RefCountedPtr<EBReflux>> m_ebReflux;
 
  mutable Vector<RefCountedPtr<EBFluxRedistribution>> m_redistributionOp;
 
  mutable Vector<RefCountedPtr<EBGradient>> m_gradientOp;
 
  mutable EBAMRParticleMesh m_particleMesh;
 
  mutable EBAMRSurfaceDeposition m_surfaceDeposition;
 
  mutable Vector<RefCountedPtr<CellCentroidInterpolation>> m_cellCentroidInterpolation;
 
  mutable Vector<RefCountedPtr<EBCentroidInterpolation>> m_ebCentroidInterpolation;
 
  mutable Vector<RefCountedPtr<EBNonConservativeDivergence>> m_nonConservativeDivergence;
 
  void
  defineEBLevelGrid(const int a_lmin);
 
  void
  defineVofIterator(const int a_lmin);
 
  void
  defineEBCoarAve(const int a_lmin);
 
  void
  defineEBMultigrid(const int a_lmin);
 
  void
  defineFillPatch(const int a_lmin);
 
  void
  defineEBCoarseToFineInterp(const int a_lmin);
 
  void
  defineMultigridInjection(const int a_lmin);
 
  void
  defineFluxReg(const int a_lmin, const int a_regsize);
 
  void
  defineRedistOper(const int a_lmin, const int a_regsize);
 
  void
  defineFineToCoarRedistOper(const int a_lmin, const int a_regsize);
 
  void
  defineCoarToFineRedistOper(const int a_lmin, const int a_regsize);
 
  void
  defineCoarToCoarRedistOper(const int a_lmin, const int a_regsize);
 
  void
  defineParticleMesh();
 
  void
  defineGradSten(const int a_lmin);
 
  void
  defineIrregSten();
 
  void
  defineNonConservativeDivergence(const int a_lmin);
 
  void
  defineLevelSet(const int a_lmin, const int a_numGhost);
 
  void
  defineMasks(const int a_lmin, const int a_numGhost);
};
 
#include <CD_NamespaceFooter.H>
 
#endif