CD_PhaseRealm.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_PhaseRealm_H
#define CD_PhaseRealm_H
 
// Chombo includes
#include <DisjointBoxLayout.H>
#include <ProblemDomain.H>
 
// Our includes
#include <CD_ComputationalGeometry.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_IrregAmrStencil.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_ParticleContainer.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_NonConservativeDivergenceStencil.H>
#include <CD_EbCentroidInterpolationStencil.H>
#include <CD_CentroidInterpolationStencil.H>
#include <CD_NamespaceHeader.H>
 
// These are operator that can be defined.
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 registeration
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 IrregStencil::StencilType    a_centroidStencil,
         const IrregStencil::StencilType    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;
 
  Vector<RefCountedPtr<LayoutData<VoFIterator>>>&
  getVofIterator() const;
 
  const IrregAmrStencil<CentroidInterpolationStencil>&
  getCentroidInterpolationStencils() const;
 
  const IrregAmrStencil<EbCentroidInterpolationStencil>&
  getEbCentroidInterpolationStencilStencils() const;
 
  const IrregAmrStencil<NonConservativeDivergenceStencil>&
  getNonConservativeDivergenceStencils() 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;
 
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;
 
  IrregStencil::StencilType m_centroidStencilType;
 
  IrregStencil::StencilType m_ebCentroidStencilType;
 
  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;
 
  mutable Vector<RefCountedPtr<LayoutData<VoFIterator>>> m_vofIter;
 
  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;
 
  RefCountedPtr<IrregAmrStencil<CentroidInterpolationStencil>> m_centroidInterpolationStencil;
 
  RefCountedPtr<IrregAmrStencil<EbCentroidInterpolationStencil>> m_ebCentroidInterpolationStencil;
 
  RefCountedPtr<IrregAmrStencil<NonConservativeDivergenceStencil>> m_NonConservativeDivergenceStencil;
 
  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
  defineNonConsDivSten();
 
  void
  defineLevelSet(const int a_lmin, const int a_numGhost);
};
 
#include <CD_NamespaceFooter.H>
 
#endif