eb_cut_cell_ Class Reference

#include <ERF_EBCutCell.H>

Collaboration diagram for eb_cut_cell_:

Classes
struct	path_data

Public Member Functions
AMREX_GPU_HOST_DEVICE	eb_cut_cell_ (amrex::EBCellFlag const &a_flag, amrex::RealBox const &a_rbox, amrex::RealVect const &a_point, amrex::RealVect const &a_normal)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	isCovered () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	isRegular () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	isSingleValued () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void	set_covered ()
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void	set_regular ()
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	volume () const
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	areaLo (int const idir) const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	areaHi (int const idir) const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	areaBoun () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	centLo (int const idir) const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	centHi (int const idir) const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	centBoun () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	normBoun () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	centVol () const noexcept
void	debug (int const a_face=-1)

Private Member Functions
AMREX_GPU_HOST_DEVICE void	calc_edge_intersections ()
AMREX_GPU_HOST_DEVICE void	set_covered_regular_cell_vertices ()

Private Attributes
amrex::RealBox const	m_rbox
amrex::RealVect const	m_eb_point
amrex::RealVect const	m_eb_normal
amrex::Real	m_invert
amrex::RealVect	m_rbox_area
amrex::EBCellFlag	m_flag
polygon_	m_F1
polygon_	m_F2
polygon_	m_F3
polygon_	m_F4
polygon_	m_F5
polygon_	m_F6
amrex::Array< amrex::RealVect, m_max_faces >	m_cellface_cent
amrex::RealVect	m_cell_cent
amrex::RealVect	m_dx
polygon_	m_F7
amrex::Array< polygon_ const *const, 3 >	m_lo_faces {&m_F4, &m_F5, &m_F1}
amrex::Array< polygon_ const *const, 3 >	m_hi_faces {&m_F2, &m_F6, &m_F3}
amrex::Array< int const, 3 >	m_lo_faces_id {3,4,0}
amrex::Array< int const, 3 >	m_hi_faces_id {1,5,2}

Static Private Attributes
static constexpr int	m_max_faces = 6

Constructor & Destructor Documentation

eb_cut_cell_()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE eb_cut_cell_::eb_cut_cell_	(	amrex::EBCellFlag const &	a_flag,
		amrex::RealBox const &	a_rbox,
		amrex::RealVect const &	a_point,
		amrex::RealVect const &	a_normal
	)

  : m_rbox(a_rbox)
  , m_eb_point(a_point)
  , m_eb_normal(a_normal)
  , m_invert(0.0)
  , m_F1(a_point, a_normal)
  , m_F2(a_point, a_normal)
  , m_F3(a_point, a_normal)
  , m_F4(a_point, a_normal)
  , m_F5(a_point, a_normal)
  , m_F6(a_point, a_normal)
  , m_cellface_cent({amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.),
                 amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.)})
{
  using namespace amrex;
 
  m_rbox_area[0] = m_rbox.length(1)*m_rbox.length(2);
  m_rbox_area[1] = m_rbox.length(0)*m_rbox.length(2);
  m_rbox_area[2] = m_rbox.length(0)*m_rbox.length(1);
 
  amrex::RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
  amrex::RealVect v1(m_rbox.hi(0), m_rbox.lo(1), m_rbox.lo(2));
  amrex::RealVect v2(m_rbox.lo(0), m_rbox.hi(1), m_rbox.lo(2));
  amrex::RealVect v3(m_rbox.lo(0), m_rbox.lo(1), m_rbox.hi(2));
  amrex::RealVect v4(m_rbox.hi(0), m_rbox.lo(1), m_rbox.hi(2));
  amrex::RealVect v5(m_rbox.hi(0), m_rbox.hi(1), m_rbox.lo(2));
  amrex::RealVect v6(m_rbox.lo(0), m_rbox.hi(1), m_rbox.hi(2));
  amrex::RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
 
  // Centroids of cell faces
 
  m_cellface_cent[0] = 0.25 * ( v0 + v2 + v5 + v1 ); // F1
  m_cellface_cent[1] = 0.25 * ( v1 + v5 + v7 + v4 ); // F2
  m_cellface_cent[2] = 0.25 * ( v3 + v4 + v7 + v6 ); // F3
  m_cellface_cent[3] = 0.25 * ( v0 + v3 + v6 + v2 ); // F4
  m_cellface_cent[4] = 0.25 * ( v0 + v1 + v4 + v3 ); // F5
  m_cellface_cent[5] = 0.25 * ( v2 + v5 + v7 + v6 ); // F6
 
  // Cell centroid
 
  m_cell_cent[0] = 0.5 * ( m_rbox.lo(0) + m_rbox.hi(0) );
  m_cell_cent[1] = 0.5 * ( m_rbox.lo(1) + m_rbox.hi(1) );
  m_cell_cent[2] = 0.5 * ( m_rbox.lo(2) + m_rbox.hi(2) );
 
  // Cell size
 
  m_dx[0] = m_rbox.hi(0) - m_rbox.lo(0);
  m_dx[1] = m_rbox.hi(1) - m_rbox.lo(1);
  m_dx[2] = m_rbox.hi(2) - m_rbox.lo(2);
 
  if (a_flag.isCovered() ) {
 
    set_covered();
 
  } else if (a_flag.isRegular() ) {
 
    set_regular();
 
  } else { // Check that the box and plane intersect.
 
    amrex::RealVect c = 0.5*(v0 + v7);
    amrex::RealVect e = v7 - c;
 
    amrex::Real r = e[0]*amrex::Math::abs(a_normal[0]) +
             e[1]*amrex::Math::abs(a_normal[1]) +
             e[2]*amrex::Math::abs(a_normal[2]);
 
    amrex::Real s = amrex::Math::abs(c.dotProduct(a_normal)
               - a_point.dotProduct(a_normal));
 
    if (s > r) {
      if ((a_normal.dotProduct(v0) - a_normal.dotProduct(a_point)) > 0.)
      { set_covered(); } else { set_regular(); }
    } else { m_flag.setSingleValued(); }
  }
 
  if ( m_flag.isSingleValued() ) {
 
    m_invert = ((m_eb_normal.dotProduct(v0) - m_eb_normal.dotProduct(m_eb_point)) > 0.) ? 0.0 : 1.0;
 
    calc_edge_intersections();
 
  } // end singleValued
 
  m_F1.define();
  m_F2.define();
  m_F3.define();
  m_F4.define();
  m_F5.define();
  m_F6.define();
  m_F7.define();
 
  // For covered and regular cut cells, add vertices to utilize e.g., get_centroid.
  if ( !m_flag.isSingleValued() ) {
    set_covered_regular_cell_vertices();
  }
 
}

Member Function Documentation

areaBoun()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::areaBoun ( ) const

inlinenoexcept

                                         {
      return m_F7.area();
    }

Referenced by eb_aux_::define().

Here is the call graph for this function:

Here is the caller graph for this function:

areaHi()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::areaHi ( int const  idir ) const

inlinenoexcept

                                                       {
      AMREX_ASSERT( idir >= 0 && idir < AMREX_SPACEDIM );
      if (m_flag.isCovered() ) { return 0.; }
      if (m_flag.isRegular() ) { return m_hi_faces[idir]->area(); }
      amrex::Real const area(m_hi_faces[idir]->area());
      return m_invert*area + (1.-m_invert)*(m_rbox_area[idir] - area);
    }

Referenced by centVol(), and eb_aux_::define().

Here is the caller graph for this function:

areaLo()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::areaLo ( int const  idir ) const

inlinenoexcept

                                                       {
      AMREX_ASSERT( idir >=0 && idir < AMREX_SPACEDIM );
      if (m_flag.isCovered() ) { return 0.; }
      if (m_flag.isRegular() ) { return m_lo_faces[idir]->area(); }
      amrex::Real const area(m_lo_faces[idir]->area());
      return m_invert*area + (1.-m_invert)*(m_rbox_area[idir] - area);
    }

Referenced by centVol(), and eb_aux_::define().

Here is the caller graph for this function:

calc_edge_intersections()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::calc_edge_intersections ( )

private

{
  using namespace amrex;
 
  amrex::RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
  amrex::RealVect v1(m_rbox.hi(0), m_rbox.lo(1), m_rbox.lo(2));
  amrex::RealVect v2(m_rbox.lo(0), m_rbox.hi(1), m_rbox.lo(2));
  amrex::RealVect v3(m_rbox.lo(0), m_rbox.lo(1), m_rbox.hi(2));
  amrex::RealVect v4(m_rbox.hi(0), m_rbox.lo(1), m_rbox.hi(2));
  amrex::RealVect v5(m_rbox.hi(0), m_rbox.hi(1), m_rbox.lo(2));
  amrex::RealVect v6(m_rbox.lo(0), m_rbox.hi(1), m_rbox.hi(2));
  amrex::RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
 
// #ifndef AMREX_USE_GPU
 
  bool print_initial = ( Math::abs(m_eb_point[0]-1.666667e-01)<1.e-4 &&
                         Math::abs(m_eb_point[1]+4.194018e-01)<1.e-4 &&
                         Math::abs(m_eb_point[2]+1.666667e-01)<1.e-4 );
  const bool print_F1 = print_initial && false;
  const bool print_F2 = print_initial && false;
  const bool print_F3 = print_initial && false;
  const bool print_F4 = print_initial && false;
  const bool print_F5 = print_initial && false;
  const bool print_F6 = print_initial && false;
  const bool print_F7 = print_initial && false;
// #endif
 
  m_F1.add_vertex(v0); if(print_F1) printf("Initial: add v0 -> F1\n");
  m_F4.add_vertex(v0); if(print_F4) printf("Initial: add v0 -> F4\n");
  m_F5.add_vertex(v0); if(print_F5) printf("Initial: add v0 -> F5\n");
 
  int add_v7(1);
 
  amrex::RealVect vIP;
  amrex::Real distIP;
 
  amrex::Array<bool,8> vertex_intersected{}; // true if vertex has been intersected within a path.
 
  //------------------------------------------------------------
  // STEP 1: Predefine edge-plane intersections along 6 paths.
  // Check how the edges intersect the plane and whether the configuration is valid.
  // If the configuration is not valid, adjust it.
  //------------------------------------------------------------
 
  amrex::Array<path_data,3> p1, p2, p3;
  path_data p4, p5, p6;
 
  // Path 1: v0->v1->v4->v7
  p1[0].set(m_eb_point, m_eb_normal, v0, v1);
  p1[1].set(m_eb_point, m_eb_normal, v1, v4);
  p1[2].set(m_eb_point, m_eb_normal, v4, v7);
 
  // Path 2: v0->v2->v5->v7
  p2[0].set(m_eb_point, m_eb_normal, v0, v2);
  p2[1].set(m_eb_point, m_eb_normal, v2, v5);
  p2[2].set(m_eb_point, m_eb_normal, v5, v7);
 
  // Path 3: v0->v3->v6->v7
  p3[0].set(m_eb_point, m_eb_normal, v0, v3);
  p3[1].set(m_eb_point, m_eb_normal, v3, v6);
  p3[2].set(m_eb_point, m_eb_normal, v6, v7);
 
  // Path 4: v1->v5
  p4.set(m_eb_point, m_eb_normal, v1, v5);
 
  // Path 5: v2->v6
  p5.set(m_eb_point, m_eb_normal, v2, v6);
 
  // Path 6: v3->v4
  p6.set(m_eb_point, m_eb_normal, v3, v4);
 
  //------------------------------------------------------------
  // STEP 2: Add vertices to faces.
  //------------------------------------------------------------
 
  // Path 1
  {
    int cuts(0);
    for (int i = 0; i < 8; ++i) vertex_intersected[i] = false;
 
    if (p1[0].intersected) {
      if (p1[0].intersected_start) {
        m_F1.add_vertex(v0); if(print_F1) printf("Path 1: v0--v1: add v0 -> F1\n");
        m_F4.add_vertex(v0); if(print_F4) printf("Path 1: v0--v1: add v0 -> F4\n");
        m_F5.add_vertex(v0); if(print_F5) printf("Path 1: v0--v1: add v0 -> F5\n");
        m_F7.add_vertex(v0); if(print_F7) printf("Path 1: v0--v1: add v0 -> F7\n");
        if (!vertex_intersected[0]) {
          vertex_intersected[0] = true;
          ++cuts;
        }
      } else if (p1[0].intersected_end) {
        m_F1.add_vertex(v1); if(print_F1) printf("Path 1: v0--v1: add v1 -> F1\n");
        m_F2.add_vertex(v1); if(print_F2) printf("Path 1: v0--v1: add v1 -> F2\n");
        m_F5.add_vertex(v1); if(print_F5) printf("Path 1: v0--v1: add v1 -> F5\n");
        m_F7.add_vertex(v1); if(print_F7) printf("Path 1: v0--v1: add v1 -> F7\n");
        if (!vertex_intersected[1]) {
          vertex_intersected[1] = true;
          ++cuts;
        }
      } else {
        m_F1.add_vertex(p1[0].vIP); if(print_F1) printf("Path 1: v0--v1: add vIP -> F1\n");
        m_F5.add_vertex(p1[0].vIP); if(print_F5) printf("Path 1: v0--v1: add vIP -> F5\n");
        m_F7.add_vertex(p1[0].vIP); if(print_F7) printf("Path 1: v0--v1: add vIP -> F7\n");
        ++cuts;
      }
 
    } // Path 1: v0--v1
 
    if (cuts%2 == 0) {
      m_F1.add_vertex(v1); if(print_F1) printf("Path 1: after v0--v1, cuts-mod-2==0: add v1 -> F1\n");
      m_F2.add_vertex(v1); if(print_F2) printf("Path 1: after v0--v1, cuts-mod-2==0: add v1 -> F2\n");
      m_F5.add_vertex(v1); if(print_F5) printf("Path 1: after v0--v1, cuts-mod-2==0: add v1 -> F5\n");
    }
 
    if (p1[1].intersected) {
      if (p1[1].intersected_start) {
        m_F1.add_vertex(v1); if(print_F1) printf("Path 1: v1--v4: add v1 -> F1\n");
        m_F2.add_vertex(v1); if(print_F2) printf("Path 1: v1--v4: add v1 -> F2\n");
        m_F5.add_vertex(v1); if(print_F5) printf("Path 1: v1--v4: add v1 -> F5\n");
        m_F7.add_vertex(v1); if(print_F7) printf("Path 1: v1--v4: add v1 -> F7\n");
        if (!vertex_intersected[1]) {
          vertex_intersected[1] = true;
          ++cuts;
        }
      } else if (p1[1].intersected_end) {
        m_F2.add_vertex(v4); if(print_F2) printf("Path 1: v1--v4: add v4 -> F2\n");
        m_F3.add_vertex(v4); if(print_F3) printf("Path 1: v1--v4: add v4 -> F3\n");
        m_F5.add_vertex(v4); if(print_F5) printf("Path 1: v1--v4: add v4 -> F5\n");
        m_F7.add_vertex(v4); if(print_F7) printf("Path 1: v1--v4: add v4 -> F7\n");
        if (!vertex_intersected[4]) {
          vertex_intersected[4] = true;
          ++cuts;
        }
      } else {
        m_F2.add_vertex(p1[1].vIP); if(print_F2) printf("Path 1: v1--v4: add vIP -> F2\n");
        m_F5.add_vertex(p1[1].vIP); if(print_F5) printf("Path 1: v1--v4: add vIP -> F5\n");
        m_F7.add_vertex(p1[1].vIP); if(print_F7) printf("Path 1: v1--v4: add vIP -> F7\n");
        ++cuts;
      }
 
    } // P1: v1--v4
 
    if (cuts%2 == 0) {
      m_F2.add_vertex(v4); if(print_F2) printf("Path 1: after v1--v4, cuts-mod-2==0: add v4 -> F2\n");
      m_F3.add_vertex(v4); if(print_F3) printf("Path 1: after v1--v4, cuts-mod-2==0: add v4 -> F3\n");
      m_F5.add_vertex(v4); if(print_F5) printf("Path 1: after v1--v4, cuts-mod-2==0: add v4 -> F5\n");
    }
 
    if (p1[2].intersected) {
      if (p1[2].intersected_start) {
        m_F2.add_vertex(v4); if(print_F2) printf("Path 1: v4--v7: add v4 -> F2\n");
        m_F3.add_vertex(v4); if(print_F3) printf("Path 1: v4--v7: add v4 -> F3\n");
        m_F5.add_vertex(v4); if(print_F5) printf("Path 1: v4--v7: add v4 -> F5\n");
        m_F7.add_vertex(v4); if(print_F7) printf("Path 1: v4--v7: add v4 -> F7\n");
        if (!vertex_intersected[4]) {
          vertex_intersected[4] = true;
          ++cuts;
        }
      } else if (p1[2].intersected_end) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 1: v4--v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 1: v4--v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 1: v4--v7: add v7 -> F6\n");
        m_F7.add_vertex(v7); if(print_F7) printf("Path 1: v4--v7: add v7 -> F7\n");
        if (!vertex_intersected[7]) {
          vertex_intersected[7] = true;
          ++cuts;
        }
      } else {
        m_F2.add_vertex(p1[2].vIP); if(print_F2) printf("Path 1: v4--v7: add vIP -> F2\n");
        m_F3.add_vertex(p1[2].vIP); if(print_F3) printf("Path 1: v4--v7: add vIP -> F3\n");
        m_F7.add_vertex(p1[2].vIP); if(print_F7) printf("Path 1: v4--v7: add vIP -> F7\n");
        ++cuts;
      }
 
    } // P1: v4--v7
 
    if (cuts == 2 && add_v7) {
      if (!intersect_plane_edge(m_eb_point, m_eb_normal, v0, v7, vIP, distIP)) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 1: after v4--v7, cuts == 2 && add_v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 1: after v4--v7, cuts == 2 && add_v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 1: after v4--v7, cuts == 2 && add_v7: add v7 -> F6\n");
        add_v7 = 0;
      }
    }
  } // end Path 1
 
  // Path 4
  if (p4.intersected) {
    if (p4.intersected_start) {
      m_F1.add_vertex(v1); if(print_F1) printf("Path 4: v1--v5: add v1 -> F1\n");
      m_F2.add_vertex(v1); if(print_F2) printf("Path 4: v1--v5: add v1 -> F2\n");
      m_F5.add_vertex(v1); if(print_F5) printf("Path 4: v1--v5: add v1 -> F5\n");
      m_F7.add_vertex(v1); if(print_F7) printf("Path 4: v1--v5: add v1 -> F7\n");
    } else if (p4.intersected_end) {
      m_F1.add_vertex(v5); if(print_F1) printf("Path 4: v1--v5: add v5 -> F1\n");
      m_F2.add_vertex(v5); if(print_F2) printf("Path 4: v1--v5: add v5 -> F2\n");
      m_F6.add_vertex(v5); if(print_F6) printf("Path 4: v1--v5: add v5 -> F6\n");
      m_F7.add_vertex(v5); if(print_F7) printf("Path 4: v1--v5: add v5 -> F7\n");
    } else {
      m_F1.add_vertex(p4.vIP); if(print_F1) printf("Path 4: v1--v5: add vIP -> F1\n");
      m_F2.add_vertex(p4.vIP); if(print_F2) printf("Path 4: v1--v5: add vIP -> F2\n");
      m_F7.add_vertex(p4.vIP); if(print_F7) printf("Path 4: v1--v5: add vIP -> F7\n");
    }
  }
 
  // Path 2
  { int cuts(0);
    for (int i = 0; i < 8; ++i) vertex_intersected[i] = false;
 
    if (p2[0].intersected) {
      if (p2[0].intersected_start) {
        m_F1.add_vertex(v0); if(print_F1) printf("Path 2: v0--v2: add v0 -> F1\n");
        m_F4.add_vertex(v0); if(print_F4) printf("Path 2: v0--v2: add v0 -> F4\n");
        m_F5.add_vertex(v0); if(print_F5) printf("Path 2: v0--v2: add v0 -> F5\n");
        m_F7.add_vertex(v0); if(print_F7) printf("Path 2: v0--v2: add v0 -> F7\n");
        if (!vertex_intersected[0]) {
          vertex_intersected[0] = true;
          ++cuts;
        }
      } else if (p2[0].intersected_end) {
        m_F1.add_vertex(v2); if(print_F1) printf("Path 2: v0--v2: add v2 -> F1\n");
        m_F4.add_vertex(v2); if(print_F4) printf("Path 2: v0--v2: add v2 -> F4\n");
        m_F6.add_vertex(v2); if(print_F6) printf("Path 2: v0--v2: add v2 -> F6\n");
        m_F7.add_vertex(v2); if(print_F7) printf("Path 2: v0--v2: add v2 -> F7\n");
        if (!vertex_intersected[2]) {
          vertex_intersected[2] = true;
          ++cuts;
        }
      } else {
        m_F1.add_vertex(p2[0].vIP); if(print_F1) printf("Path 2: v0--v2: add vIP -> F1\n");
        m_F4.add_vertex(p2[0].vIP); if(print_F4) printf("Path 2: v0--v2: add vIP -> F4\n");
        m_F7.add_vertex(p2[0].vIP); if(print_F7) printf("Path 2: v0--v2: add vIP -> F7\n");
        ++cuts;
      }
 
    } // P2: v0--v2
 
    if (cuts%2 == 0) {
      m_F1.add_vertex(v2); if(print_F1) printf("Path 2: after v0--v2, cuts-mod-2==0: add v2 -> F1\n");
      m_F4.add_vertex(v2); if(print_F4) printf("Path 2: after v0--v2, cuts-mod-2==0: add v2 -> F4\n");
      m_F6.add_vertex(v2); if(print_F6) printf("Path 2: after v0--v2, cuts-mod-2==0: add v2 -> F6\n");
    }
 
    if (p2[1].intersected) {
      if (p2[1].intersected_start) {
        m_F1.add_vertex(v2); if(print_F1) printf("Path 2: v2--v5: add v2 -> F1\n");
        m_F4.add_vertex(v2); if(print_F4) printf("Path 2: v2--v5: add v2 -> F4\n");
        m_F6.add_vertex(v2); if(print_F6) printf("Path 2: v2--v5: add v2 -> F6\n");
        m_F7.add_vertex(v2); if(print_F7) printf("Path 2: v2--v5: add v2 -> F7\n");
        if (!vertex_intersected[2]) {
          vertex_intersected[2] = true;
          ++cuts;
        }
      } else if (p2[1].intersected_end) {
        m_F1.add_vertex(v5); if(print_F1) printf("Path 2: v2--v5: add v5 -> F1\n");
        m_F2.add_vertex(v5); if(print_F2) printf("Path 2: v2--v5: add v5 -> F2\n");
        m_F6.add_vertex(v5); if(print_F6) printf("Path 2: v2--v5: add v5 -> F6\n");
        m_F7.add_vertex(v5); if(print_F7) printf("Path 2: v2--v5: add v5 -> F7\n");
        if (!vertex_intersected[5]) {
          vertex_intersected[5] = true;
          ++cuts;
        }
      } else {
        m_F1.add_vertex(p2[1].vIP); if(print_F1) printf("Path 2: v2--v5: add vIP -> F1\n");
        m_F6.add_vertex(p2[1].vIP); if(print_F6) printf("Path 2: v2--v5: add vIP -> F6\n");
        m_F7.add_vertex(p2[1].vIP); if(print_F7) printf("Path 2: v2--v5: add vIP -> F7\n");
        ++cuts;
      }
    }
 
    if (cuts%2 == 0) {
      m_F1.add_vertex(v5); if(print_F1) printf("Path 2: after v2--v5, cuts-mod-2==0: add v5 -> F1\n");
      m_F2.add_vertex(v5); if(print_F2) printf("Path 2: after v2--v5, cuts-mod-2==0: add v5 -> F2\n");
      m_F6.add_vertex(v5); if(print_F6) printf("Path 2: after v2--v5, cuts-mod-2==0: add v5 -> F6\n");
    }
 
    if (p2[2].intersected) {
      if (p2[2].intersected_start) {
        m_F1.add_vertex(v5); if(print_F1) printf("Path 2: v5--v7: add v5 -> F1\n");
        m_F2.add_vertex(v5); if(print_F2) printf("Path 2: v5--v7: add v5 -> F2\n");
        m_F6.add_vertex(v5); if(print_F6) printf("Path 2: v5--v7: add v5 -> F6\n");
        m_F7.add_vertex(v5); if(print_F7) printf("Path 2: v5--v7: add v5 -> F7\n");
        if (!vertex_intersected[5]) {
          vertex_intersected[5] = true;
          ++cuts;
        }
      } else if (p2[2].intersected_end) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 2: v5--v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 2: v5--v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 2: v5--v7: add v7 -> F6\n");
        m_F7.add_vertex(v7); if(print_F7) printf("Path 2: v5--v7: add v7 -> F7\n");
        if (!vertex_intersected[7]) {
          vertex_intersected[7] = true;
          ++cuts;
        }
      } else {
        m_F2.add_vertex(p2[2].vIP); if(print_F2) printf("Path 2: v5--v7: add vIP -> F2\n");
        m_F6.add_vertex(p2[2].vIP); if(print_F6) printf("Path 2: v5--v7: add vIP -> F6\n");
        m_F7.add_vertex(p2[2].vIP); if(print_F7) printf("Path 2: v5--v7: add vIP -> F7\n");
        ++cuts;
      }
    } // Path 2: v5--v7
 
    if (cuts == 2 && add_v7) {
      if (!intersect_plane_edge(m_eb_point, m_eb_normal, v0, v7, vIP, distIP)) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 2: after v5--v7, cuts == 2 && add_v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 2: after v5--v7, cuts == 2 && add_v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 2: after v5--v7, cuts == 2 && add_v7: add v7 -> F6\n");
        add_v7 = 0;
      }
    }
 
  } // end Path 2
 
  // Path 5
  if (p5.intersected) {
    if (p5.intersected_start) {
      m_F1.add_vertex(v2); if(print_F1) printf("Path 5: v2--v6: add v2 -> F1\n");
      m_F4.add_vertex(v2); if(print_F4) printf("Path 5: v2--v6: add v2 -> F4\n");
      m_F6.add_vertex(v2); if(print_F6) printf("Path 5: v2--v6: add v2 -> F6\n");
      m_F7.add_vertex(v2); if(print_F7) printf("Path 5: v2--v6: add v2 -> F7\n");
    } else if (p5.intersected_end) {
      m_F3.add_vertex(v6); if(print_F3) printf("Path 5: v2--v6: add v6 -> F3\n");
      m_F4.add_vertex(v6); if(print_F4) printf("Path 5: v2--v6: add v6 -> F4\n");
      m_F6.add_vertex(v6); if(print_F6) printf("Path 5: v2--v6: add v6 -> F6\n");
      m_F7.add_vertex(v6); if(print_F7) printf("Path 5: v2--v6: add v6 -> F7\n");
    } else {
      m_F4.add_vertex(p5.vIP); if(print_F4) printf("Path 5: v2--v6: add vIP -> F4\n");
      m_F6.add_vertex(p5.vIP); if(print_F6) printf("Path 5: v2--v6: add vIP -> F6\n");
      m_F7.add_vertex(p5.vIP); if(print_F7) printf("Path 5: v2--v6: add vIP -> F7\n");
    }
  } // end Path 5
 
 
  // Path 3
  { int cuts(0);
    for (int i = 0; i < 8; ++i) vertex_intersected[i] = false;
 
    if (p3[0].intersected) {
      if (p3[0].intersected_start) {
        m_F1.add_vertex(v0); if(print_F1) printf("Path 3: v0--v3: add v0 -> F1\n");
        m_F4.add_vertex(v0); if(print_F4) printf("Path 3: v0--v3: add v0 -> F4\n");
        m_F5.add_vertex(v0); if(print_F5) printf("Path 3: v0--v3: add v0 -> F5\n");
        m_F7.add_vertex(v0); if(print_F7) printf("Path 3: v0--v3: add v0 -> F7\n");
        if (!vertex_intersected[0]) {
          vertex_intersected[0] = true;
          ++cuts;
        }
      } else if (p3[0].intersected_end) {
        m_F3.add_vertex(v3); if(print_F3) printf("Path 3: v0--v3: add v3 -> F3\n");
        m_F4.add_vertex(v3); if(print_F4) printf("Path 3: v0--v3: add v3 -> F4\n");
        m_F5.add_vertex(v3); if(print_F5) printf("Path 3: v0--v3: add v3 -> F5\n");
        m_F7.add_vertex(v3); if(print_F7) printf("Path 3: v0--v3: add v3 -> F7\n");
        if (!vertex_intersected[3]) {
          vertex_intersected[3] = true;
          ++cuts;
        }
      } else {
        m_F4.add_vertex(p3[0].vIP); if(print_F4) printf("Path 3: v0--v3: add vIP -> F4\n");
        m_F5.add_vertex(p3[0].vIP); if(print_F5) printf("Path 3: v0--v3: add vIP -> F5\n");
        m_F7.add_vertex(p3[0].vIP); if(print_F7) printf("Path 3: v0--v3: add vIP -> F7\n");
        ++cuts;
      }
 
    } // P3: v0--v3
 
    if (cuts%2 == 0) {
      m_F3.add_vertex(v3); if(print_F3) printf("Path 3: after v0--v3, cuts-mod-2 == 0: add v3 -> F3\n");
      m_F4.add_vertex(v3); if(print_F4) printf("Path 3: after v0--v3, cuts-mod-2 == 0: add v3 -> F4\n");
      m_F5.add_vertex(v3); if(print_F5) printf("Path 3: after v0--v3, cuts-mod-2 == 0: add v3 -> F5\n");
    }
 
    if (p3[1].intersected) {
      if (p3[1].intersected_start) {
        m_F3.add_vertex(v3); if(print_F3) printf("Path 3: v3--v6: add v3 -> F3\n");
        m_F4.add_vertex(v3); if(print_F4) printf("Path 3: v3--v6: add v3 -> F4\n");
        m_F5.add_vertex(v3); if(print_F5) printf("Path 3: v3--v6: add v3 -> F5\n");
        m_F7.add_vertex(v3); if(print_F7) printf("Path 3: v3--v6: add v3 -> F7\n");
        if (!vertex_intersected[3]) {
          vertex_intersected[3] = true;
          ++cuts;
        }
      } else if (p3[1].intersected_end) {
        m_F3.add_vertex(v6); if(print_F3) printf("Path 3: v3--v6: add v6 -> F3\n");
        m_F4.add_vertex(v6); if(print_F4) printf("Path 3: v3--v6: add v6 -> F4\n");
        m_F6.add_vertex(v6); if(print_F6) printf("Path 3: v3--v6: add v6 -> F6\n");
        m_F7.add_vertex(v6); if(print_F7) printf("Path 3: v3--v6: add v6 -> F7\n");
        if (!vertex_intersected[6]) {
          vertex_intersected[6] = true;
          ++cuts;
        }
      } else {
        m_F3.add_vertex(p3[1].vIP); if(print_F3) printf("Path 3: v3--v6: add vIP -> F3\n");
        m_F4.add_vertex(p3[1].vIP); if(print_F4) printf("Path 3: v3--v6: add vIP -> F4\n");
        m_F7.add_vertex(p3[1].vIP); if(print_F7) printf("Path 3: v3--v6: add vIP -> F7\n");
        ++cuts;
      }
 
    } // P3: v3--v6
 
    if (cuts%2 == 0) {
      m_F3.add_vertex(v6); if(print_F3) printf("Path 3: after v3--v6, cuts-mod-2 == 0: add v6 -> F3\n");
      m_F4.add_vertex(v6); if(print_F4) printf("Path 3: after v3--v6, cuts-mod-2 == 0: add v6 -> F4\n");
      m_F6.add_vertex(v6); if(print_F6) printf("Path 3: after v3--v6, cuts-mod-2 == 0: add v6 -> F6\n");
    }
 
    if (p3[2].intersected) {
      if (p3[2].intersected_start) {
        m_F3.add_vertex(v6); if(print_F3) printf("Path 3: v6--v7: add v6 -> F3\n");
        m_F4.add_vertex(v6); if(print_F4) printf("Path 3: v6--v7: add v6 -> F4\n");
        m_F6.add_vertex(v6); if(print_F6) printf("Path 3: v6--v7: add v6 -> F6\n");
        m_F7.add_vertex(v6); if(print_F7) printf("Path 3: v6--v7: add v6 -> F7\n");
        if (!vertex_intersected[6]) {
          vertex_intersected[6] = true;
          ++cuts;
        }
      } else if (p3[2].intersected_end) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 3: v6--v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 3: v6--v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 3: v6--v7: add v7 -> F6\n");
        m_F7.add_vertex(v7); if(print_F7) printf("Path 3: v6--v7: add v7 -> F7\n");
        if (!vertex_intersected[7]) {
          vertex_intersected[7] = true;
          ++cuts;
        }
      } else {
        m_F3.add_vertex(p3[2].vIP); if(print_F3) printf("Path 3: v6--v7: add vIP -> F3\n");
        m_F6.add_vertex(p3[2].vIP); if(print_F6) printf("Path 3: v6--v7: add vIP -> F6\n");
        m_F7.add_vertex(p3[2].vIP); if(print_F7) printf("Path 3: v6--v7: add vIP -> F7\n");
        ++cuts;
      }
    } // P3: v6--v7
 
    if (cuts == 2 && add_v7) {
      if (!intersect_plane_edge(m_eb_point, m_eb_normal, v0, v7, vIP, distIP)) {
        m_F2.add_vertex(v7); if(print_F2) printf("Path 3: after v6--v7, cuts == 2 && add_v7: add v7 -> F2\n");
        m_F3.add_vertex(v7); if(print_F3) printf("Path 3: after v6--v7, cuts == 2 && add_v7: add v7 -> F3\n");
        m_F6.add_vertex(v7); if(print_F6) printf("Path 3: after v6--v7, cuts == 2 && add_v7: add v7 -> F6\n");
        add_v7 = 0;
      }
    }
 
  } // end Path 3
 
  // Path 6
  if (p6.intersected) {
    if (p6.intersected_start) {
      m_F3.add_vertex(v3); if(print_F3) printf("Path 6: v3--v4: add v3 -> F3\n");
      m_F4.add_vertex(v3); if(print_F4) printf("Path 6: v3--v4: add v3 -> F4\n");
      m_F5.add_vertex(v3); if(print_F5) printf("Path 6: v3--v4: add v3 -> F5\n");
      m_F7.add_vertex(v3); if(print_F7) printf("Path 6: v3--v4: add v3 -> F7\n");
    } else if (p6.intersected_end) {
      m_F2.add_vertex(v4); if(print_F2) printf("Path 6: v3--v4: add v4 -> F2\n");
      m_F3.add_vertex(v4); if(print_F3) printf("Path 6: v3--v4: add v4 -> F3\n");
      m_F5.add_vertex(v4); if(print_F5) printf("Path 6: v3--v4: add v4 -> F5\n");
      m_F7.add_vertex(v4); if(print_F7) printf("Path 6: v3--v4: add v4 -> F7\n");
    } else {
      m_F3.add_vertex(p6.vIP); if(print_F3) printf("Path 6: v3--v4: add vIP -> F3\n");
      m_F5.add_vertex(p6.vIP); if(print_F5) printf("Path 6: v3--v4: add vIP -> F5\n");
      m_F7.add_vertex(p6.vIP); if(print_F7) printf("Path 6: v3--v4: add vIP -> F7\n");
    }
  } // end Path 6
 
  if (print_F1 || print_F2 || print_F3 || print_F4 || print_F5 || print_F6 || print_F7){
    printf("\n");
  }
 
}

Here is the call graph for this function:

centBoun()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect eb_cut_cell_::centBoun ( ) const

inlinenoexcept

                                             {
      amrex::RealVect cent{0.,0.,0.};
      if (m_flag.isSingleValued()) {
        cent = m_F7.get_centroid();
      }
      return cent;
    }

Referenced by eb_aux_::define().

Here is the call graph for this function:

Here is the caller graph for this function:

centHi()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect eb_cut_cell_::centHi ( int const  idir ) const

inlinenoexcept

                                                           {
      AMREX_ASSERT( idir >=0 && idir < AMREX_SPACEDIM );
      amrex::RealVect cent = m_cellface_cent[ m_hi_faces_id[idir] ];
      if (m_flag.isCovered() || m_flag.isRegular() ) {
        // Default cent
      } else {
        amrex::Real const area_R = m_hi_faces[idir]->area();
        if (amrex::almostEqual(area_R,0.0) || amrex::almostEqual(area_R, m_rbox_area[idir]) ){
          // Default cent
        } else {
          amrex::RealVect   cent_O = cent;
          amrex::RealVect   cent_R = m_hi_faces[idir]->get_centroid();
          amrex::Real const area_C = m_rbox_area[idir] - area_R;
          cent = m_invert * cent_R + (1.-m_invert) * ((1.+area_R/area_C)*cent_O - area_R/area_C*cent_R);
        }
      }
      return cent;
    }

Referenced by eb_aux_::define().

Here is the caller graph for this function:

centLo()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect eb_cut_cell_::centLo ( int const  idir ) const

inlinenoexcept

                                                           {
      AMREX_ASSERT( idir >=0 && idir < AMREX_SPACEDIM );
      amrex::RealVect cent = m_cellface_cent[ m_lo_faces_id[idir] ];
      if (m_flag.isCovered() || m_flag.isRegular() ) {
        // Default cent
      } else {
        amrex::Real const area_R = m_lo_faces[idir]->area();
        if (amrex::almostEqual(area_R,0.0) || amrex::almostEqual(area_R, m_rbox_area[idir]) ){
          // Default cent
        } else {
          amrex::RealVect   cent_O = cent;
          amrex::RealVect   cent_R = m_lo_faces[idir]->get_centroid();
          amrex::Real const area_C = m_rbox_area[idir] - area_R;
          cent = m_invert * cent_R + (1.-m_invert) * ((1.+area_R/area_C)*cent_O - area_R/area_C*cent_R);
        }
      }
      return cent;
    }

Referenced by eb_aux_::define().

Here is the caller graph for this function:

centVol()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect eb_cut_cell_::centVol ( ) const

inlinenoexcept

                                            {
      amrex::RealVect vcent = m_cell_cent;
      if (m_flag.isSingleValued()) {
        amrex::Real xm = m_rbox.lo(0);
        amrex::Real xp = m_rbox.hi(0);
        amrex::Real ym = m_rbox.lo(1);
        amrex::Real yp = m_rbox.hi(1);
        amrex::Real zm = m_rbox.lo(2);
        amrex::Real zp = m_rbox.hi(2);
 
        amrex::Real axm = areaLo(0);
        amrex::Real axp = areaHi(0);
        amrex::Real aym = areaLo(1);
        amrex::Real ayp = areaHi(1);
        amrex::Real azm = areaLo(2);
        amrex::Real azp = areaHi(2);
 
        amrex::Real barea = m_F7.area();
        amrex::RealVect bcent = m_F7.get_centroid();
 
        amrex::Real vol = volume();
 
        vcent[0] = 0.5 * ( - xm * xm * axm + xp * xp * axp + bcent[0] * bcent[0] * m_eb_normal[0] * barea ) / vol;
        vcent[1] = 0.5 * ( - ym * ym * aym + yp * yp * ayp + bcent[1] * bcent[1] * m_eb_normal[1] * barea ) / vol;
        vcent[2] = 0.5 * ( - zm * zm * azm + zp * zp * azp + bcent[2] * bcent[2] * m_eb_normal[2] * barea ) / vol;
      }
      return vcent;
    }

Referenced by eb_aux_::define().

Here is the call graph for this function:

Here is the caller graph for this function:

debug()

void eb_cut_cell_::debug

(

int const

a_face = -1

)

                           {
 
  amrex::Print() << "\n\nDEBUG THIS "
    << "--------------------------------------"
    << "\nisCovered?       " << isCovered()
    << "\nisRegular?       " << isRegular()
    << "\nisSingleValued?  " << isSingleValued()
    << "\n";
 
  if ( isCovered() || isRegular() ) { return; }
 
  amrex::RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
  amrex::RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
 
  amrex::Print() << "\n"
          << "lo:     " << v0 << '\n'
          << "hi:     " << v7 << '\n'
          << "p:      " << m_eb_point << '\n'
          << "n:      " << m_eb_normal << '\n'
          << "invert? " << m_invert << "\n\n";
 
  amrex::Print() << "Edge intersections:\n";
  calc_edge_intersections();
  amrex::Print() << '\n';
 
  if ( a_face == -1 || a_face == 1 ) { m_F1.report(1, v0); }
  if ( a_face == -1 || a_face == 2 ) { m_F2.report(2, v0); }
  if ( a_face == -1 || a_face == 3 ) { m_F3.report(3, v0); }
  if ( a_face == -1 || a_face == 4 ) { m_F4.report(4, v0); }
  if ( a_face == -1 || a_face == 5 ) { m_F5.report(5, v0); }
  if ( a_face == -1 || a_face == 6 ) { m_F6.report(6, v0); }
  if ( a_face == -1 || a_face == 7 ) { m_F7.report(7, v0); }
}

Referenced by eb_aux_::define().

Here is the caller graph for this function:

isCovered()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool eb_cut_cell_::isCovered ( ) const

inlinenoexcept

{ return m_flag.isCovered(); }

Referenced by eb_aux_::define().

Here is the caller graph for this function:

isRegular()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool eb_cut_cell_::isRegular ( ) const

inlinenoexcept

{ return m_flag.isRegular(); }

Referenced by eb_aux_::define().

Here is the caller graph for this function:

isSingleValued()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool eb_cut_cell_::isSingleValued ( ) const

inlinenoexcept

{ return m_flag.isSingleValued(); }

normBoun()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect eb_cut_cell_::normBoun ( ) const

inlinenoexcept

                                             {
      amrex::RealVect normal{0.,0.,0.};
      if (m_flag.isSingleValued()) {
        normal = m_eb_normal;
      }
      return normal;
    }

set_covered()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::set_covered ( )

inline

                        {
      m_flag.setCovered();
    }

set_covered_regular_cell_vertices()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::set_covered_regular_cell_vertices ( )

private

{
  using namespace amrex;
 
  RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
  RealVect v1(m_rbox.hi(0), m_rbox.lo(1), m_rbox.lo(2));
  RealVect v2(m_rbox.lo(0), m_rbox.hi(1), m_rbox.lo(2));
  RealVect v3(m_rbox.lo(0), m_rbox.lo(1), m_rbox.hi(2));
  RealVect v4(m_rbox.hi(0), m_rbox.lo(1), m_rbox.hi(2));
  RealVect v5(m_rbox.hi(0), m_rbox.hi(1), m_rbox.lo(2));
  RealVect v6(m_rbox.lo(0), m_rbox.hi(1), m_rbox.hi(2));
  RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
 
  // Add vertices in the order of outward normal vector
 
  m_F1.add_vertex(v0);
  m_F1.add_vertex(v2);
  m_F1.add_vertex(v5);
  m_F1.add_vertex(v1);
 
  m_F2.add_vertex(v1);
  m_F2.add_vertex(v5);
  m_F2.add_vertex(v7);
  m_F2.add_vertex(v4);
 
  m_F3.add_vertex(v3);
  m_F3.add_vertex(v4);
  m_F3.add_vertex(v7);
  m_F3.add_vertex(v6);
 
  m_F4.add_vertex(v0);
  m_F4.add_vertex(v3);
  m_F4.add_vertex(v6);
  m_F4.add_vertex(v2);
 
  m_F5.add_vertex(v0);
  m_F5.add_vertex(v1);
  m_F5.add_vertex(v4);
  m_F5.add_vertex(v3);
 
  m_F6.add_vertex(v2);
  m_F6.add_vertex(v5);
  m_F6.add_vertex(v7);
  m_F6.add_vertex(v6);
 
}

Here is the call graph for this function:

set_regular()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::set_regular ( )

inline

                        {
 
      m_flag.setRegular();
 
      m_F1.set_area( m_rbox.length(0)*m_rbox.length(1) );
      m_F3.set_area( m_rbox.length(0)*m_rbox.length(1) );
 
      m_F2.set_area( m_rbox.length(1)*m_rbox.length(2) );
      m_F4.set_area( m_rbox.length(1)*m_rbox.length(2) );
 
      m_F5.set_area( m_rbox.length(0)*m_rbox.length(2) );
      m_F6.set_area( m_rbox.length(0)*m_rbox.length(2) );
 
      m_F7.set_area(0.);
 
    }

Here is the call graph for this function:

volume()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::volume ( ) const

inline

                              {
 
      if (m_flag.isCovered() ) { return 0.; }
      if (m_flag.isRegular() ) { return m_rbox.volume(); }
 
      amrex::Real volume(0.);
 
      amrex::Real const* lo = m_rbox.lo();
      amrex::RealVect v0(lo[0], lo[1], lo[2]);
 
      if (m_F2.ok() ) { volume += m_F2.area() * m_F2.distance(v0); }
      if (m_F3.ok() ) { volume += m_F3.area() * m_F3.distance(v0); }
      if (m_F6.ok() ) { volume += m_F6.area() * m_F6.distance(v0); }
      if (m_F7.ok() ) { volume += m_F7.area() * m_F7.distance(v0); }
 
      volume /= 3.;
 
      return m_invert*volume + (1.-m_invert)*(m_rbox.volume()-volume);
    }

Referenced by centVol(), and eb_aux_::define().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_cell_cent

amrex::RealVect eb_cut_cell_::m_cell_cent

private

Referenced by centVol().

m_cellface_cent

amrex::Array<amrex::RealVect,m_max_faces> eb_cut_cell_::m_cellface_cent

private

Referenced by centHi(), and centLo().

m_dx

amrex::RealVect eb_cut_cell_::m_dx

private

m_eb_normal

amrex::RealVect const eb_cut_cell_::m_eb_normal

private

Referenced by calc_edge_intersections(), centVol(), and normBoun().

m_eb_point

amrex::RealVect const eb_cut_cell_::m_eb_point

private

Referenced by calc_edge_intersections().

m_F1

polygon_ eb_cut_cell_::m_F1

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), and set_regular().

m_F2

polygon_ eb_cut_cell_::m_F2

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), set_regular(), and volume().

m_F3

polygon_ eb_cut_cell_::m_F3

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), set_regular(), and volume().

m_F4

polygon_ eb_cut_cell_::m_F4

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), and set_regular().

m_F5

polygon_ eb_cut_cell_::m_F5

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), and set_regular().

m_F6

polygon_ eb_cut_cell_::m_F6

private

Referenced by calc_edge_intersections(), set_covered_regular_cell_vertices(), set_regular(), and volume().

m_F7

polygon_ eb_cut_cell_::m_F7

private

Referenced by areaBoun(), calc_edge_intersections(), centBoun(), centVol(), set_regular(), and volume().

m_flag

amrex::EBCellFlag eb_cut_cell_::m_flag

private

Referenced by areaHi(), areaLo(), centBoun(), centHi(), centLo(), centVol(), isCovered(), isRegular(), isSingleValued(), normBoun(), set_covered(), set_regular(), and volume().

m_hi_faces

amrex::Array<polygon_ const* const,3> eb_cut_cell_::m_hi_faces {&m_F2, &m_F6, &m_F3}

private

Referenced by areaHi(), and centHi().

m_hi_faces_id

amrex::Array<int const,3> eb_cut_cell_::m_hi_faces_id {1,5,2}

private

Referenced by centHi().

m_invert

amrex::Real eb_cut_cell_::m_invert

private

Referenced by areaHi(), areaLo(), centHi(), centLo(), and volume().

m_lo_faces

amrex::Array<polygon_ const* const,3> eb_cut_cell_::m_lo_faces {&m_F4, &m_F5, &m_F1}

private

Referenced by areaLo(), and centLo().

m_lo_faces_id

amrex::Array<int const,3> eb_cut_cell_::m_lo_faces_id {3,4,0}

private

Referenced by centLo().

m_max_faces

constexpr int eb_cut_cell_::m_max_faces = 6

staticconstexprprivate

m_rbox

amrex::RealBox const eb_cut_cell_::m_rbox

private

Referenced by calc_edge_intersections(), centVol(), set_covered_regular_cell_vertices(), set_regular(), and volume().

m_rbox_area

amrex::RealVect eb_cut_cell_::m_rbox_area

private

Referenced by areaHi(), areaLo(), centHi(), and centLo().

---

The documentation for this class was generated from the following files:

• Source/EB/ERF_EBCutCell.H
• Source/EB/ERF_EBCutCell.cpp