ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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_DEVICE void add_vertex (amrex::RealVect const &a_v)
 
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_vertices
 
amrex::Real m_area
 
int m_sorted
 
amrex::Array< amrex::RealVect, m_max_verticesm_vertex
 
amrex::GpuArray< amrex::Real, m_max_verticesm_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
16  : m_cell_face(1)
17  , m_eb_point(a_point)
18  , m_eb_normal(a_normal)
19  , m_defined(0)
20  , m_vertices(0)
21  , m_area(0.)
22  , m_sorted(0)
23  , m_vertex({amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.),
24  amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.)})
25  , m_zdir(0.)
26  {}
int m_defined
Definition: ERF_EBPolygon.H:217
amrex::Real m_area
Definition: ERF_EBPolygon.H:221
int const m_cell_face
Definition: ERF_EBPolygon.H:212
int m_sorted
Definition: ERF_EBPolygon.H:223
int m_vertices
Definition: ERF_EBPolygon.H:219
amrex::Array< amrex::RealVect, m_max_vertices > m_vertex
Definition: ERF_EBPolygon.H:225
amrex::RealVect const m_eb_normal
Definition: ERF_EBPolygon.H:215
amrex::RealVect const m_eb_point
Definition: ERF_EBPolygon.H:214
amrex::RealVect m_zdir
Definition: ERF_EBPolygon.H:229

◆ polygon_() [2/2]

AMREX_GPU_HOST_DEVICE polygon_::polygon_ ( )
inline
30  : m_cell_face(0)
31  , m_eb_point(0.)
32  , m_eb_normal(0.)
33  , m_defined(0)
34  , m_vertices(0)
35  , m_area(0.)
36  , m_sorted(0)
37  , m_vertex({amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.),
38  amrex::RealVect(0.), amrex::RealVect(0.), amrex::RealVect(0.)})
39  , m_zdir(0.)
40  {}

Member Function Documentation

◆ add_vertex()

AMREX_GPU_HOST_DEVICE void polygon_::add_vertex ( amrex::RealVect const &  a_v)
inline
43  {
44  for ( int i(0); i<m_vertices; ++i) {
45  if ( amrex::almostEqual(m_vertex[i][0],a_v[0]) && amrex::almostEqual(m_vertex[i][1],a_v[1])
46  && amrex::almostEqual(m_vertex[i][2],a_v[2]) ) {
47  return;
48  }
49  }
50  AMREX_ASSERT( m_vertices < m_max_vertices );
51  m_vertex[m_vertices] = a_v;
52  m_vertices++;
53  }
static constexpr int m_max_vertices
Definition: ERF_EBPolygon.H:210

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
129  {
130  AMREX_ALWAYS_ASSERT( ok() ); // <-------------------------------------- TODO remove ALWAYS
131  return m_area;
132  }
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int ok() const noexcept
Definition: ERF_EBPolygon.H:125

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
204  {
205  debug(-1);
206  }
void debug()
Definition: ERF_EBPolygon.H:204

◆ debug() [2/2]

void polygon_::debug ( int const  a_id)
inline
198  {
199  amrex::Print() << "EBPolygon: id = " << a_id << ", m_vertices = " << m_vertices << '\n';
200  for (int i(0); i<m_vertices; ++i) {
201  amrex::Print() << "EBPolygon: v" << i << ": " << m_vertex[i] << '\n';
202  }
203  }

◆ define()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void polygon_::define ( )
inline
59  {
60 
61  AMREX_ALWAYS_ASSERT( m_defined == 0 ); // TODO ---------------------------- remove ALWAYS
62 
63  m_defined = 1;
64 
65  // We need at least 3 faces.
66  if (m_vertices < 3) { return; }
67 
68  // Check to see if the vertices of the face are inside or outside of the plane.
69  // If they are outside, this face doesn't belong to the volume.
70  if ( m_cell_face ) {
71  for ( int i(0); i<m_vertices; ++i) {
72  if ((m_eb_normal.dotProduct(m_vertex[i] - m_eb_point)) >= 0.) {
73  } else {
74  }
75  }
76  }
77 
78  // Calculate the centroid of the polygon.
79  amrex::RealVect centroid = get_centroid();
80 
81  // Shift the vertices relative to the centroid
82  amrex::Array<amrex::RealVect,m_max_vertices> vertex_cent;
83  for ( int i(0); i<m_vertices; ++i) { vertex_cent[i] = m_vertex[i] - centroid; }
84 
85  // Find a vertex that isn't inline with v[0] and the centroid so we can
86  // compute a vector normal to the face.
87  for ( int i(1); i<m_vertices; ++i ) {
88  m_zdir = vertex_cent[0].crossProduct(vertex_cent[i]);
89  if ( !amrex::almostEqual(m_zdir.vectorLength(),0.) ) { break; }
90  }
91  AMREX_ALWAYS_ASSERT(!amrex::almostEqual(m_zdir.vectorLength(), 0.));
92  m_zdir /= m_zdir.vectorLength();
93 
94  m_theta[0] = 0.0;
95  for ( int i(1); i<m_vertices; ++i) {
96 
97  m_theta[i] = std::atan2(m_zdir.dotProduct( vertex_cent[0].crossProduct(vertex_cent[i]) ),
98  vertex_cent[0].dotProduct(vertex_cent[i]));
99 
100  m_theta[i] += ((m_theta[i] >= 0.) ? 0.0 : 2.0*PI);
101  }
102 
103  // Sort counter clockwise based on theta.
104  for (int i(0); i<m_vertices; ++i) {
105  for (int j(0); j < m_vertices-i-1; ++j) {
106  if ( m_theta[j] > m_theta[j+1] ) {
107  amrex::Swap(m_theta[j], m_theta[j+1]);
108  amrex::Swap(m_vertex[j], m_vertex[j+1]);
109  amrex::Swap(vertex_cent[j], vertex_cent[j+1]);
110  }
111  } // j-loop
112  } // i-loop
113  m_sorted = 1;
114 
115  // Compute areas of triangles
116  for (int i(0); i<m_vertices; ++i) {
117  int const j( (i+1 == m_vertices) ? 0 : i+1 );
118  amrex::RealVect vi_cross_vj = vertex_cent[i].crossProduct(vertex_cent[j]);
119  m_area += 0.5*vi_cross_vj.vectorLength();
120  }
121  AMREX_ALWAYS_ASSERT( m_area > 0. ); // <------------------------------- TODO remove ALWAYS
122  }
constexpr amrex::Real PI
Definition: ERF_Constants.H:6
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect get_centroid() const noexcept
Definition: ERF_EBPolygon.H:144
amrex::GpuArray< amrex::Real, m_max_vertices > m_theta
Definition: ERF_EBPolygon.H:227
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
136  {
137  AMREX_ALWAYS_ASSERT( m_defined == 1 ); // <--------------------------- TODO remove ALWAYS
138  amrex::RealVect x0 = a_point - m_vertex[0];
139  return amrex::Math::abs(x0.dotProduct(m_zdir));
140  }

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
144  {
145  amrex::RealVect cent(0.);
146  if (m_vertices==3) {
147  cent = (m_vertex[0] + m_vertex[1] + m_vertex[2]) / 3.0;
148  } else {
149  // Loop over sub-triangles
150  amrex::Real area(0.);
151  for ( int i(0); i<m_vertices-2; ++i) {
152  amrex::RealVect const v0 (m_vertex[i+1] - m_vertex[0]);
153  amrex::RealVect const v1 (m_vertex[i+2] - m_vertex[0]);
154  amrex::RealVect v0_cross_v1 = v0.crossProduct(v1);
155  amrex::Real area_tri = 0.5 * v0_cross_v1.vectorLength();
156  amrex::RealVect cent_tri = (m_vertex[0] + m_vertex[i+1] + m_vertex[i+2]) / 3.0;
157  area += area_tri;
158  cent += area_tri * cent_tri;
159  }
160  cent = cent / area;
161  }
162  return cent;
163  }
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real area() const noexcept
Definition: ERF_EBPolygon.H:129

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:

◆ normal()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::RealVect polygon_::normal ( ) const
inlinenoexcept
167  {
168  return m_zdir;
169  }

◆ ok()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int polygon_::ok ( ) const
inlinenoexcept
126  { 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
176  {
177 
178 #ifndef AMREX_USE_GPU
179  amrex::RealVect centroid = get_centroid();
180  amrex::Print() << "Face " << a_id
181  << " -------------------------------------------\n"
182  << "\nok? " << (ok() ? "yes" : "no") << "\n\n";
183  for (int i(0); i<m_vertices; ++i) {
184  amrex::Print() << "v" << i << ": " << m_vertex[i] << '\n';
185  }
186  amrex::Print() << "\nvc: " << " " << centroid << "\n";
187 
188  amrex::Real const dist = distance( a_v0 );
189  // amrex::Real const vol = ok() ? m_area * dist : 0.;
190 
191  amrex::Print() << "\narea: " << m_area
192  << "\ndistance: " << dist
193  << "\nvolume: " << dist*m_area
194  << "\n==================================================\n\n";
195 #endif
196  }
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real distance(amrex::RealVect const &a_point) const noexcept
Definition: ERF_EBPolygon.H:136
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
56 { 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_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_vertex

amrex::Array<amrex::RealVect,m_max_vertices> polygon_::m_vertex
private

◆ m_vertices

int polygon_::m_vertices
private

◆ 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: