CD_PolyhedralGeometryShop.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_POLYHEDRALGEOMETRYSHOP_H
#define CD_POLYHEDRALGEOMETRYSHOP_H
 
// Std includes
#include <string>
 
// Chombo includes
#include <BaseFab.H>
#include <IntVectSet.H>
 
// Our includes
#include <CD_ScanShop.H>
#include <CD_CutCellBody.H>
#include <CD_CutCellSurface.H>
#include <CD_PolyhedralEBGraph.H>
#include <CD_MultiFluidIndexSpace.H>
#include <CD_NamespaceHeader.H>
 
class ComputationalGeometry;
 
class PolyhedralGeometryShop : public ScanShop
{
public:
  enum class UnresolvedAction
  {
    Warn,
 
    Cover,
 
    Collapse
  };
 
  PolyhedralGeometryShop() = delete;
 
  PolyhedralGeometryShop(const BaseIF&        a_localGeom,
                         const int            a_verbosity,
                         const Real           a_dx,
                         const RealVect&      a_probLo,
                         const ProblemDomain& a_finestDomain,
                         const ProblemDomain& a_scanLevel,
                         const int            a_ebGhost,
                         const Real           a_thrshdVoF,
                         const bool           a_strict);
 
  ~PolyhedralGeometryShop() override;
 
  PolyhedralGeometryShop(const PolyhedralGeometryShop& a_other) = delete;
 
  PolyhedralGeometryShop&
  operator=(const PolyhedralGeometryShop& a_other) = delete;
 
  void
  fillGraph(BaseFab<int>&        a_regIrregCovered,
            Vector<IrregNode>&   a_nodes,
            const Box&           a_validRegion,
            const Box&           a_ghostRegion,
            const ProblemDomain& a_domain,
            const RealVect&      a_probLo,
            const Real&          a_dx,
            const DataIndex&     a_di) const override;
 
  void
  setGrids(const ComputationalGeometry& a_compGeom, const phase::which_phase a_phase) noexcept;
 
  void
  buildGraphs();
 
  const PolyhedralEBGraph&
  getGraph(const int a_level) const noexcept;
 
  void
  verifySurface() const;
 
  void
  sanityCheck() const;
 
  void
  reportUnresolvedRefinement() const;
 
  void
  testGraphCopy() const;
 
  static bool
  isDust(const PolyhedralEB::CutCellBody& a_body) noexcept;
 
  static void
  fillNodeValues(const BaseIF&   a_function,
                 BaseFab<Real>&  a_nodeValues,
                 const Box&      a_region,
                 const RealVect& a_probLo,
                 const Real&     a_dx);
 
  static void
  defineIntercepts(BaseFab<Real> a_intercept[SpaceDim], const Box& a_region);
 
  static Real
  edgeCrossing(const BaseIF&   a_function,
               BaseFab<Real>   a_intercept[SpaceDim],
               const IntVect&  a_cell,
               const int       a_edge,
               const Real      a_lo,
               const Real      a_hi,
               const RealVect& a_probLo,
               const Real&     a_dx);
 
  static void
  fillCorners(PolyhedralEB::CutCellSurface& a_surface, const BaseFab<Real>& a_nodeValues, const IntVect& a_cell);
 
  static void
  buildSurface(const BaseIF&                 a_function,
               BaseFab<Real>                 a_intercept[SpaceDim],
               PolyhedralEB::CutCellSurface& a_surface,
               const BaseFab<Real>&          a_nodeValues,
               const IntVect&                a_cell,
               const RealVect&               a_probLo,
               const Real&                   a_dx);
 
  static Real
  edgeRoot(const BaseIF&   a_function,
           const IntVect&  a_edgeIV,
           const int       a_dir,
           const Real      a_loValue,
           const Real      a_hiValue,
           const RealVect& a_probLo,
           const Real      a_dx) noexcept;
 
  static constexpr Real s_snapTolerance = 1.0E-12;
 
  static constexpr Real s_rootSnap = 1.0E-4;
 
  static constexpr Real s_probeSpacing = 1.0E-6;
 
  static Real
  snappedValue(const BaseIF& a_function, const RealVect& a_point, const Real a_dx) noexcept;
 
  static Real
  resolveTangency(const BaseIF& a_function, const RealVect& a_point, const Real a_dx) noexcept;
 
protected:
  static constexpr Real s_weldSpacing = 1.0E-6;
 
  const ComputationalGeometry* m_compGeom;
 
  Vector<RefCountedPtr<PolyhedralEBGraph>> m_graphs;
 
  phase::which_phase m_phase;
 
  bool m_writeSurface;
 
  bool m_sanityCheck;
 
  bool m_profile;
 
  int m_maxRefinement;
 
  UnresolvedAction m_unresolvedAction;
 
  bool m_testCopy;
 
  bool m_verbose;
 
  void
  collectFacets(Vector<Real>& a_facets, const int a_level) const;
 
  void
  sanityCheck(const Vector<RefCountedPtr<PolyhedralEBGraph>>& a_graphs) const;
 
#if CH_SPACEDIM == 3
  void
  defineBody(PolyhedralEB::CutCellBody&                  a_body,
             const PolyhedralEBGraph&                    a_graph,
             const IVSFAB<PolyhedralEB::CutCellSurface>& a_surfaces,
             const BaseFab<signed char>&                 a_states,
             const BaseFab<signed char>&                 a_refined,
             const IntVect&                              a_cell) const;
#endif
 
  void
  writeSurface(const std::string& a_fileName, const Vector<Vector<Real>>& a_facets) const;
 
  static void
  indexFacets(const Vector<Real>& a_facets,
              const Real          a_tolerance,
              std::vector<Real>&  a_vertices,
              std::vector<int>&   a_connectivity);
 
  static constexpr Real s_divergenceTolerance = 1.0E-9;
 
  bool m_strict;
 
  Real m_volumeThreshold;
 
  void
  fillNode(IrregNode&                       a_node,
           const PolyhedralEB::CutCellBody& a_body,
           const BaseFab<int>&              a_regIrregCovered,
           const IntVect&                   a_cell,
           const ProblemDomain&             a_domain) const;
};
 
#include <CD_NamespaceFooter.H>
 
#endif