polygon_ Class Reference

#include <ERF_EBPolygon.H>

Collaboration diagram for polygon_:

Public Member Functions
AMREX_GPU_HOST_DEVICE	polygon_ (amrex::RealVect a_point, amrex::RealVect a_normal)
AMREX_GPU_HOST_DEVICE	polygon_ ()
AMREX_GPU_HOST void	add_vertex (amrex::RealVect const &a_v, const std::string &msg, bool print_msg=false)
AMREX_GPU_HOST_DEVICE void	add_vertex (amrex::RealVect const &a_v)
AMREX_GPU_HOST_DEVICE int	get_num_vertices ()
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void	set_area (amrex::Real const &a_area)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void	define ()
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int	ok () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	area () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	distance (amrex::RealVect const &a_point) const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	get_centroid () const noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect	normal () const noexcept
void	report (int const a_id, amrex::RealVect a_v0)
void	debug (int const a_id)
void	debug ()

Private Attributes
int const	m_cell_face
amrex::RealVect const	m_eb_point
amrex::RealVect const	m_eb_normal
int	m_defined
int	m_num_vertices
amrex::Real	m_area
int	m_sorted
amrex::Array< amrex::RealVect, m_max_vertices >	m_vertices
amrex::GpuArray< amrex::Real, m_max_vertices >	m_theta
amrex::RealVect	m_zdir

Static Private Attributes
static constexpr int	m_max_vertices = 6

Constructor & Destructor Documentation

polygon_() [1/2]

AMREX_GPU_HOST_DEVICE polygon_::polygon_ ( amrex::RealVect  a_point, amrex::RealVect  a_normal  )

inline

      : m_cell_face(1)
      , m_eb_point(a_point)
      , m_eb_normal(a_normal)
      , m_defined(0)
      , m_num_vertices(0)
      , m_area(0.)
      , m_sorted(0)
      , m_vertices({amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.),
                  amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.)})
      , m_zdir(0.)
    {}

polygon_() [2/2]

AMREX_GPU_HOST_DEVICE polygon_::polygon_ ( )

inline

      : m_cell_face(0)
      , m_eb_point(0.)
      , m_eb_normal(0.)
      , m_defined(0)
      , m_num_vertices(0)
      , m_area(0.)
      , m_sorted(0)
      , m_vertices({amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.),
                  amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.)})
      , m_zdir(0.)
    {}

Member Function Documentation

add_vertex() [1/2]

AMREX_GPU_HOST_DEVICE void polygon_::add_vertex ( amrex::RealVect const &  a_v )

inline

                                                 {
      for ( int i(0); i<m_num_vertices; ++i) {
        if ( amrex::almostEqual(m_vertices[i][0],a_v[0]) &&
             amrex::almostEqual(m_vertices[i][1],a_v[1]) &&
             amrex::almostEqual(m_vertices[i][2],a_v[2]) ) {
          return;
        }
      }
      AMREX_ASSERT( m_num_vertices < m_max_vertices );
      m_vertices[m_num_vertices] = a_v;
      m_num_vertices++;
    }

add_vertex() [2/2]

AMREX_GPU_HOST void polygon_::add_vertex ( amrex::RealVect const &  a_v, const std::string &  msg, bool  print_msg = false  )

inline

    {
      if (print_msg) {
        amrex::Print() << msg << "\n";
      }
      add_vertex(a_v);
    }

Referenced by eb_cut_cell_::calc_edge_intersections(), and eb_cut_cell_::set_covered_regular_cell_vertices().

Here is the caller graph for this function:

area()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real polygon_::area ( ) const

inlinenoexcept

                                      {
      AMREX_ALWAYS_ASSERT( ok() ); // <-------------------------------------- TODO remove ALWAYS
      return m_area;
    }

Referenced by eb_cut_cell_::areaBoun(), eb_cut_cell_::centVol(), get_centroid(), and eb_cut_cell_::volume().

Here is the call graph for this function:

Here is the caller graph for this function:

debug() [1/2]

void polygon_::debug ( )

inline

                 {
      debug(-1);
    }

debug() [2/2]

void polygon_::debug ( int const  a_id )

inline

                                 {
      amrex::Print() << "EBPolygon: id = " << a_id << ", m_num_vertices = " << m_num_vertices << '\n';
      for (int i(0); i<m_num_vertices; ++i) {
        amrex::Print() << "EBPolygon: v" << i << ":  " << m_vertices[i] << '\n';
      }
    }

define()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void polygon_::define ( )

inline

                   {
 
      AMREX_ALWAYS_ASSERT( m_defined == 0 );  // TODO ---------------------------- remove ALWAYS
 
      m_defined = 1;
 
      // We need at least 3 faces.
      if (m_num_vertices < 3) { return; }
 
      // Check to see if the vertices of the face are inside or outside of the plane.
      // If they are outside, this face doesn't belong to the volume.
      if ( m_cell_face ) {
        for ( int i(0); i<m_num_vertices; ++i) {
          if ((m_eb_normal.dotProduct(m_vertices[i] - m_eb_point)) >= 0.) {
          } else {
          }
        }
      }
 
      // Calculate the centroid of the polygon.
      amrex::RealVect centroid = get_centroid();
 
      // Shift the vertices relative to the centroid
      amrex::Array<amrex::RealVect,m_max_vertices> vertex_cent;
      for ( int i(0); i<m_num_vertices; ++i) {
        vertex_cent[i] = m_vertices[i] - centroid;
      }
 
      // Compute the normal vector m_zdir by cross product of two vectors in vertex_cent.
      // Choose the vectors with the largest cross-product magnitude.
      amrex::RealVect v_normal;
      amrex::Real max_norm2 = -1.0;
      const amrex::RealVect& vertex_cent_0 = vertex_cent[0];
 
      for (int i = 1; i < m_num_vertices; ++i)
      {
        amrex::RealVect vi = vertex_cent[i];
        amrex::RealVect v_cross = vertex_cent_0.crossProduct(vi);
        amrex::Real n2 = v_cross.radSquared();
        if (n2 > max_norm2)
        {
          max_norm2 = n2;
          v_normal = v_cross;
        }
      }
      if (!amrex::almostEqual(max_norm2, 0.0))
      {
          v_normal /= std::sqrt(max_norm2);
      }
      m_zdir = v_normal;
 
      //
 
      m_theta[0] = 0.0;
      for ( int i(1); i<m_num_vertices; ++i) {
 
        m_theta[i] = std::atan2(m_zdir.dotProduct( vertex_cent[0].crossProduct(vertex_cent[i]) ),
                              vertex_cent[0].dotProduct(vertex_cent[i]));
 
        m_theta[i] += ((m_theta[i] >= 0.) ? 0.0 : 2.0*PI);
      }
 
      // Sort counter clockwise based on theta.
      for (int i(0); i<m_num_vertices; ++i) {
        for (int j(0); j < m_num_vertices-i-1; ++j) {
          if ( m_theta[j] > m_theta[j+1] ) {
            amrex::Swap(m_theta[j], m_theta[j+1]);
            amrex::Swap(m_vertices[j], m_vertices[j+1]);
            amrex::Swap(vertex_cent[j], vertex_cent[j+1]);
          }
        } // j-loop
      } // i-loop
      m_sorted = 1;
 
      // Compute areas of triangles
 
      for (int i(0); i<m_num_vertices; ++i) {
        int const j( (i+1 == m_num_vertices) ? 0 : i+1 );
        amrex::RealVect vi_cross_vj = vertex_cent[i].crossProduct(vertex_cent[j]);
        m_area += 0.5*vi_cross_vj.vectorLength();
      }
      AMREX_ALWAYS_ASSERT( m_area > 0. ); // <------------------------------- TODO remove ALWAYS
    } // void define

Here is the call graph for this function:

distance()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real polygon_::distance ( amrex::RealVect const &  a_point ) const

inlinenoexcept

                                                                       {
      AMREX_ALWAYS_ASSERT( m_defined == 1 );  // <--------------------------- TODO remove ALWAYS
      amrex::RealVect x0 = a_point - m_vertices[0];
      return amrex::Math::abs(x0.dotProduct(m_zdir));
    }

Referenced by report(), and eb_cut_cell_::volume().

Here is the caller graph for this function:

get_centroid()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect polygon_::get_centroid ( ) const

inlinenoexcept

                                                  {
      amrex::RealVect cent(0.);
      if (m_num_vertices==3) {
        cent = (m_vertices[0] + m_vertices[1] + m_vertices[2]) / 3.0;
      } else {
        // Loop over sub-triangles
        amrex::Real area(0.);
        for ( int i(0); i<m_num_vertices-2; ++i) {
          amrex::RealVect const v0 (m_vertices[i+1] - m_vertices[0]);
          amrex::RealVect const v1 (m_vertices[i+2] - m_vertices[0]);
          amrex::RealVect v0_cross_v1 = v0.crossProduct(v1);
          amrex::Real area_tri = 0.5 * v0_cross_v1.vectorLength();
          amrex::RealVect cent_tri = (m_vertices[0] + m_vertices[i+1] + m_vertices[i+2]) / 3.0;
          area += area_tri;
          cent += area_tri * cent_tri;
        }
        cent = cent / area;
      }
      return cent;
    }

Referenced by eb_cut_cell_::centBoun(), eb_cut_cell_::centVol(), define(), and report().

Here is the call graph for this function:

Here is the caller graph for this function:

get_num_vertices()

AMREX_GPU_HOST_DEVICE int polygon_::get_num_vertices ( )

inline

                             {
      return m_num_vertices;
    }

normal()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect polygon_::normal ( ) const

inlinenoexcept

                                           {
      return m_zdir;
    }

ok()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int polygon_::ok ( ) const

inlinenoexcept

    { return ((m_area > 0. || (m_area == 0. && m_defined == 1)) ? 1 : 0); }

Referenced by area(), report(), and eb_cut_cell_::volume().

Here is the caller graph for this function:

report()

void polygon_::report ( int const  a_id, amrex::RealVect  a_v0  )

inline

    {
 
#ifndef AMREX_USE_GPU
      amrex::RealVect centroid = get_centroid();
      amrex::Print() << "Face " << a_id
        << " -------------------------------------------\n"
        << "\nok? " << (ok() ? "yes" : "no") << "\n\n";
      for (int i(0); i<m_num_vertices; ++i) {
        amrex::Print() << "v" << i << ":  " << m_vertices[i] << '\n';
      }
      amrex::Print() << "\nvc: " << "  " << centroid << "\n";
 
      amrex::Real const dist = distance( a_v0 );
      // amrex::Real const vol  = ok() ? m_area * dist : 0.;
 
      amrex::Print() << "\narea:     " << m_area
                     << "\ndistance: " << dist
                     << "\nvolume:   " << dist*m_area
      << "\n==================================================\n\n";
#endif
    }

Here is the call graph for this function:

set_area()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void polygon_::set_area ( amrex::Real const &  a_area )

inline

{ m_area = a_area; }

Referenced by eb_cut_cell_::set_regular().

Here is the caller graph for this function:

Member Data Documentation

m_area

amrex::Real polygon_::m_area

private

Referenced by area(), define(), ok(), report(), and set_area().

m_cell_face

int const polygon_::m_cell_face

private

Referenced by define().

m_defined

int polygon_::m_defined

private

Referenced by define(), distance(), and ok().

m_eb_normal

amrex::RealVect const polygon_::m_eb_normal

private

Referenced by define().

m_eb_point

amrex::RealVect const polygon_::m_eb_point

private

Referenced by define().

m_max_vertices

constexpr int polygon_::m_max_vertices = 6

staticconstexprprivate

Referenced by add_vertex().

m_num_vertices

int polygon_::m_num_vertices

private

Referenced by add_vertex(), debug(), define(), get_centroid(), get_num_vertices(), and report().

m_sorted

int polygon_::m_sorted

private

Referenced by define().

m_theta

amrex::GpuArray<amrex::Real,m_max_vertices> polygon_::m_theta

private

Referenced by define().

m_vertices

amrex::Array<amrex::RealVect,m_max_vertices> polygon_::m_vertices

private

Referenced by add_vertex(), debug(), define(), distance(), get_centroid(), and report().

m_zdir

amrex::RealVect polygon_::m_zdir

private

Referenced by define(), distance(), and normal().

---

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

• Source/EB/ERF_EBPolygon.H