ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Public Member Functions | Private Member Functions | Private Attributes | List of all members
eb_cut_cell_ Class Reference

#include <ERF_EBCutCell.H>

Collaboration diagram for eb_cut_cell_:
Collaboration graph
[legend]

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 ()
 
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real areaLo (int const a_idim) const noexcept
 
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real areaHi (int const a_idim) const noexcept
 
void debug (int const a_face=-1)
 

Private Member Functions

AMREX_GPU_HOST_DEVICE void calc_edge_intersections (int const a_dry_run=0)
 

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
 
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}
 

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 
)
132  : m_rbox(a_rbox)
133  , m_eb_point(a_point)
134  , m_eb_normal(a_normal)
135  , m_invert(0.0)
136  , m_F1(a_point, a_normal)
137  , m_F2(a_point, a_normal)
138  , m_F3(a_point, a_normal)
139  , m_F4(a_point, a_normal)
140  , m_F5(a_point, a_normal)
141  , m_F6(a_point, a_normal)
142 {
143  using namespace amrex;
144 
145  m_rbox_area[0] = m_rbox.length(1)*m_rbox.length(2);
146  m_rbox_area[1] = m_rbox.length(0)*m_rbox.length(2);
147  m_rbox_area[2] = m_rbox.length(0)*m_rbox.length(1);
148 
149  RealVect v0(a_rbox.lo(0), a_rbox.lo(1), a_rbox.lo(2));
150  RealVect v7(a_rbox.hi(0), a_rbox.hi(1), a_rbox.hi(2));
151 
152  if (a_flag.isCovered() ) {
153 
154  set_covered();
155 
156  } else if (a_flag.isRegular() ) {
157 
158  set_regular();
159 
160  } else { // Check that the box and plane intersect.
161 
162  RealVect c = 0.5*(v0 + v7);
163  RealVect e = v7 - c;
164 
165  Real r = e[0]*amrex::Math::abs(a_normal[0]) +
166  e[1]*amrex::Math::abs(a_normal[1]) +
167  e[2]*amrex::Math::abs(a_normal[2]);
168 
169  Real s = amrex::Math::abs(c.dotProduct(a_normal)
170  - a_point.dotProduct(a_normal));
171 
172  if (s > r) {
173  if (a_normal.dotProduct(v0 - a_point) > 0.)
174  { set_covered(); } else { set_regular(); }
175  } else { m_flag.setSingleValued(); }
176  }
177 
178  if ( m_flag.isSingleValued() ) {
179 
180  m_invert = ((m_eb_normal.dotProduct(v0 - m_eb_point)) > 0.) ? 0.0 : 1.0;
181 
182  calc_edge_intersections();
183 
184  } // end singleValued
185 
186  m_F1.define();
187  m_F2.define();
188  m_F3.define();
189  m_F4.define();
190  m_F5.define();
191  m_F6.define();
192  m_F7.define();
193 
194 }
eb_cut_cell_::m_F6
polygon_ m_F6
Definition: ERF_EBCutCell.H:112
eb_cut_cell_::m_rbox_area
amrex::RealVect m_rbox_area
Definition: ERF_EBCutCell.H:101
eb_cut_cell_::m_eb_point
amrex::RealVect const m_eb_point
Definition: ERF_EBCutCell.H:96
eb_cut_cell_::m_invert
amrex::Real m_invert
Definition: ERF_EBCutCell.H:99
eb_cut_cell_::m_rbox
amrex::RealBox const m_rbox
Definition: ERF_EBCutCell.H:95
eb_cut_cell_::set_regular
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void set_regular()
Definition: ERF_EBCutCell.H:35
eb_cut_cell_::m_F1
polygon_ m_F1
Definition: ERF_EBCutCell.H:107
eb_cut_cell_::m_F3
polygon_ m_F3
Definition: ERF_EBCutCell.H:109
eb_cut_cell_::m_flag
amrex::EBCellFlag m_flag
Definition: ERF_EBCutCell.H:103
eb_cut_cell_::calc_edge_intersections
AMREX_GPU_HOST_DEVICE void calc_edge_intersections(int const a_dry_run=0)
Definition: ERF_EBCutCell.H:200
eb_cut_cell_::m_F5
polygon_ m_F5
Definition: ERF_EBCutCell.H:111
eb_cut_cell_::set_covered
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void set_covered()
Definition: ERF_EBCutCell.H:32
eb_cut_cell_::m_F7
polygon_ m_F7
Definition: ERF_EBCutCell.H:115
eb_cut_cell_::m_eb_normal
amrex::RealVect const m_eb_normal
Definition: ERF_EBCutCell.H:97
eb_cut_cell_::m_F2
polygon_ m_F2
Definition: ERF_EBCutCell.H:108
eb_cut_cell_::m_F4
polygon_ m_F4
Definition: ERF_EBCutCell.H:110
polygon_::define
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void define()
Definition: ERF_EBPolygon.H:53
amrex
Definition: ERF_ConsoleIO.cpp:12
Here is the call graph for this function:

Member Function Documentation

◆ areaHi()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::areaHi ( int const  a_idim) const
inlinenoexcept
83  {
84  AMREX_ASSERT( a_idim > 0 && a_idim < AMREX_SPACEDIM );
85  if (m_flag.isCovered() ) { return 0.; }
86  if (m_flag.isRegular() ) { return 1.; }
87  amrex::Real const area(m_hi_faces[a_idim]->area());
88  return m_invert*area + (1.-m_invert)*(m_rbox_area[a_idim] - area);
89  }
eb_cut_cell_::m_hi_faces
amrex::Array< polygon_ const *const, 3 > m_hi_faces
Definition: ERF_EBCutCell.H:118

Referenced by 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  a_idim) const
inlinenoexcept
74  {
75  AMREX_ASSERT( a_idim >0 && a_idim < AMREX_SPACEDIM );
76  if (m_flag.isCovered() ) { return 0.; }
77  if (m_flag.isRegular() ) { return 1.; }
78  amrex::Real const area(m_lo_faces[a_idim]->area());
79  return m_invert*area + (1.-m_invert)*(m_rbox_area[a_idim] - area);
80  }
eb_cut_cell_::m_lo_faces
amrex::Array< polygon_ const *const, 3 > m_lo_faces
Definition: ERF_EBCutCell.H:117

Referenced by 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 ( int const  a_dry_run = 0)
private
201 {
202  using namespace amrex;
203 
204  RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
205  RealVect v1(m_rbox.hi(0), m_rbox.lo(1), m_rbox.lo(2));
206  RealVect v2(m_rbox.lo(0), m_rbox.hi(1), m_rbox.lo(2));
207  RealVect v3(m_rbox.lo(0), m_rbox.lo(1), m_rbox.hi(2));
208  RealVect v4(m_rbox.hi(0), m_rbox.lo(1), m_rbox.hi(2));
209  RealVect v5(m_rbox.hi(0), m_rbox.hi(1), m_rbox.lo(2));
210  RealVect v6(m_rbox.lo(0), m_rbox.hi(1), m_rbox.hi(2));
211  RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
212 
213  if (!a_dry_run) {
214  m_F1.add_vertex(v0);
215  m_F4.add_vertex(v0);
216  m_F5.add_vertex(v0);
217  }
218 
219  int add_v7(1);
220 
221  RealVect vIP;
222  Real distIP;
223 
224  // Path 1
225  { int cuts(0);
226 
227  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v0, v1, vIP, distIP)) {
228 
229  ++cuts;
230 #ifndef AMREX_USE_GPU
231  if (a_dry_run) { Print() << "P1: v0--v1: add vIP to F1, F5 and F7 :: " << vIP[0] << "\n"; }
232  else
233 #endif
234  {
235  m_F1.add_vertex(vIP);
236  m_F5.add_vertex(vIP);
237  m_F7.add_vertex(vIP);
238  }
239 
240  if ( almostEqual(distIP, 0.0) ) {
241 #ifndef AMREX_USE_GPU
242  if (a_dry_run) { Print() << "P1: v0--v1: intersection ~ 0 :: add vIP to F4\n"; }
243  else
244 #endif
245  { m_F4.add_vertex(vIP); }
246 
247  } else if ( almostEqual(distIP, 1.0) ) {
248 #ifndef AMREX_USE_GPU
249  if (a_dry_run) { Print() << "P1: v0--v1: intersection ~ 1 :: add vIP to F2\n"; }
250  else
251 #endif
252  { m_F2.add_vertex(vIP); }
253  }
254 
255  }
256 
257  if (cuts%2 == 0) {
258 
259 #ifndef AMREX_USE_GPU
260  if (a_dry_run) { Print() << "P1: Add v1 to F1, F2 and F5\n"; }
261  else
262 #endif
263  {
264  m_F1.add_vertex(v1);
265  m_F2.add_vertex(v1);
266  m_F5.add_vertex(v1);
267  }
268  }
269 
270  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v1, v4, vIP, distIP)) {
271 
272  ++cuts;
273 
274 #ifndef AMREX_USE_GPU
275  if (a_dry_run) { Print() << "P1: v1--v4: add vIP to F2, F5 and F7 :: " << vIP[2] << "\n"; }
276  else
277 #endif
278  {
279  m_F2.add_vertex(vIP);
280  m_F5.add_vertex(vIP);
281  m_F7.add_vertex(vIP);
282  }
283 
284  if ( almostEqual(distIP, 0.0) ) {
285 #ifndef AMREX_USE_GPU
286  if (a_dry_run) { Print() << "P1: v1--v4: intersection ~ 0 :: add vIP to F1\n"; }
287  else
288 #endif
289  {m_F1.add_vertex(vIP); }
290 
291  } else if ( almostEqual(distIP, 1.0) ) {
292 #ifndef AMREX_USE_GPU
293  if (a_dry_run) { Print() << "P1: v1--v4: intersection ~ 1 :: add vIP to F3\n"; }
294  else
295 #endif
296  { m_F3.add_vertex(vIP); }
297  }
298 
299  }
300 
301  if (cuts%2 == 0) {
302 
303 #ifndef AMREX_USE_GPU
304  if (a_dry_run) { Print() << "P1: Add v4 to F2, F3 and F5\n"; }
305  else
306 #endif
307  {
308  m_F2.add_vertex(v4);
309  m_F3.add_vertex(v4);
310  m_F5.add_vertex(v4);
311  }
312  }
313 
314  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v4, v7, vIP, distIP)) {
315 
316  ++cuts;
317 
318 #ifndef AMREX_USE_GPU
319  if (a_dry_run) { Print() << "P1: v4--v7: add vIP to F2, F3 and F7 :: " << vIP[1] << "\n"; }
320  else
321 #endif
322  {
323  m_F2.add_vertex(vIP);
324  m_F3.add_vertex(vIP);
325  m_F7.add_vertex(vIP);
326  }
327 
328  if ( almostEqual(distIP, 0.0)) {
329 #ifndef AMREX_USE_GPU
330  if (a_dry_run) { Print() << "P1: v4--v7: intersection ~ 0 :: add vIP to F5\n"; }
331  else
332 #endif
333  { m_F5.add_vertex(vIP); }
334 
335  } else if ( almostEqual(distIP, 1.0)) {
336 #ifndef AMREX_USE_GPU
337  if (a_dry_run) { Print() << "P1: v4--v7: intersection ~ 1 :: add vIP to F6\n"; }
338  else
339 #endif
340  { m_F6.add_vertex(vIP); }
341  }
342  }
343 
344  if (cuts == 2 && add_v7) {
345 
346 #ifndef AMREX_USE_GPU
347  if (a_dry_run) { Print() << "P1: Add v7 to F2, F3 and F6\n"; }
348  else
349 #endif
350  {
351  m_F2.add_vertex(v7);
352  m_F3.add_vertex(v7);
353  m_F6.add_vertex(v7);
354  }
355 
356  add_v7 = 0;
357  }
358  } // end Path 1
359 
360  // Path 4
361  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v1, v5, vIP, distIP)) {
362 
363 #ifndef AMREX_USE_GPU
364  if (a_dry_run) { Print() << "P4: v1--v5: add vIP to F1, F2 and F7 :: " << vIP[1] << "\n"; }
365  else
366 #endif
367  {
368  m_F1.add_vertex(vIP);
369  m_F2.add_vertex(vIP);
370  m_F7.add_vertex(vIP);
371  }
372 
373  if ( almostEqual(distIP, 0.0)) {
374 #ifndef AMREX_USE_GPU
375  if (a_dry_run) { Print() << "P1: v1--v5: intersection ~ 0 :: add vIP to F5\n"; }
376  else
377 #endif
378  { m_F5.add_vertex(vIP); }
379 
380  } else if ( almostEqual(distIP, 1.0)) {
381 #ifndef AMREX_USE_GPU
382  if (a_dry_run) { Print() << "P1: v1--v5: intersection ~ 1 :: add vIP to F6\n"; }
383  else
384 #endif
385  { m_F6.add_vertex(vIP); }
386  }
387  }
388 
389 
390  // Path 2
391  { int cuts(0);
392 
393  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v0, v2, vIP, distIP)) {
394 
395  ++cuts;
396 
397 #ifndef AMREX_USE_GPU
398  if (a_dry_run) { Print() << "P2: v0--v2: add vIP to F1, F4 and F7 :: " << vIP[1] << "\n"; }
399  else
400 #endif
401  {
402  m_F1.add_vertex(vIP);
403  m_F4.add_vertex(vIP);
404  m_F7.add_vertex(vIP);
405  }
406 
407  if ( almostEqual(distIP, 0.0)) {
408 #ifndef AMREX_USE_GPU
409  if (a_dry_run) { Print() << "P2: v0--v2: intersection ~ 0 :: add vIP to F5\n"; }
410  else
411 #endif
412  { m_F5.add_vertex(vIP); }
413 
414  } else if ( almostEqual(distIP, 1.0)) {
415 #ifndef AMREX_USE_GPU
416  if (a_dry_run) { Print() << "P2: v0--v2: intersection ~ 1 :: add vIP to F6\n"; }
417  else
418 #endif
419  { m_F6.add_vertex(vIP); }
420  }
421 
422  }
423 
424  if (cuts%2 == 0) {
425 
426 #ifndef AMREX_USE_GPU
427  if (a_dry_run) { Print() << "P2: Add v2 to F1, F4, F6\n"; }
428  else
429 #endif
430  {
431  m_F1.add_vertex(v2);
432  m_F4.add_vertex(v2);
433  m_F6.add_vertex(v2);
434  }
435  }
436 
437  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v2, v5, vIP, distIP)) {
438 
439  ++cuts;
440 
441 #ifndef AMREX_USE_GPU
442  if (a_dry_run) { Print() << "P2: v2--v5: add vIP to F1, F6 and F7 :: " << vIP[0] << "\n"; }
443  else
444 #endif
445  {
446  m_F1.add_vertex(vIP);
447  m_F6.add_vertex(vIP);
448  m_F7.add_vertex(vIP);
449  }
450 
451  if ( almostEqual(distIP, 0.0)) {
452 #ifndef AMREX_USE_GPU
453  if (a_dry_run) { Print() << "P2: v2--v5: intersection ~ 0 :: add vIP to F4\n"; }
454  else
455 #endif
456  { m_F4.add_vertex(vIP); }
457 
458  } else if ( almostEqual(distIP, 1.0)) {
459 #ifndef AMREX_USE_GPU
460  if (a_dry_run) { Print() << "P2: v2--v5: intersection ~ 1 :: add vIP to F2\n"; }
461  else
462 #endif
463  { m_F2.add_vertex(vIP); }
464  }
465  }
466 
467  if (cuts%2 == 0) {
468 
469 #ifndef AMREX_USE_GPU
470  if (a_dry_run) { Print() << "P2: Add v5 to F1, F2 and F6\n"; }
471  else
472 #endif
473  {
474  m_F1.add_vertex(v5);
475  m_F2.add_vertex(v5);
476  m_F6.add_vertex(v5);
477  }
478  }
479 
480  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v5, v7, vIP, distIP)) {
481 
482  ++cuts;
483 
484 #ifndef AMREX_USE_GPU
485  if (a_dry_run) { Print() << "P2: v5--v7: add vIP to F2, F6 and F7 :: " << vIP[2] << "\n"; }
486  else
487 #endif
488  {
489  m_F2.add_vertex(vIP);
490  m_F6.add_vertex(vIP);
491  m_F7.add_vertex(vIP);
492  }
493 
494  if ( almostEqual(distIP, 0.0)) {
495 #ifndef AMREX_USE_GPU
496  if (a_dry_run) { Print() << "P2: v5--v7: intersection ~ 0 :: add vIP to F1\n"; }
497  else
498 #endif
499  { m_F1.add_vertex(vIP); }
500 
501  } else if ( almostEqual(distIP, 1.0)) {
502 #ifndef AMREX_USE_GPU
503  if (a_dry_run) { Print() << "P2: v5--v7: intersection ~ 1 :: add vIP to F3\n"; }
504  else
505 #endif
506  { m_F3.add_vertex(vIP); }
507  }
508  }
509 
510  if (cuts == 2 && add_v7) {
511 
512 #ifndef AMREX_USE_GPU
513  if (a_dry_run) { Print() << "P2: Add v7 to F2, F3 and F6\n"; }
514  else
515 #endif
516  {
517  m_F2.add_vertex(v7);
518  m_F3.add_vertex(v7);
519  m_F6.add_vertex(v7);
520  }
521 
522  add_v7 = 0;
523  }
524 
525  } // end Path 2
526 
527  // Path 5
528  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v2, v6, vIP, distIP)) {
529 
530 #ifndef AMREX_USE_GPU
531  if (a_dry_run) { Print() << "P5: v2--v6: add vIP to F4, F6 and F7 :: " << vIP[2] << "\n"; }
532  else
533 #endif
534  {
535  m_F4.add_vertex(vIP);
536  m_F6.add_vertex(vIP);
537  m_F7.add_vertex(vIP);
538  }
539 
540  if ( almostEqual(distIP, 0.0)) {
541 #ifndef AMREX_USE_GPU
542  if (a_dry_run) { Print() << "P5: v2--v6: intersection ~ 0 :: add vIP to F1\n"; }
543  else
544 #endif
545  { m_F1.add_vertex(vIP); }
546 
547  } else if ( almostEqual(distIP, 1.0)) {
548 #ifndef AMREX_USE_GPU
549  if (a_dry_run) { Print() << "P5: v2--v6: intersection ~ 1 :: add vIP to F3\n"; }
550  else
551 #endif
552  { m_F3.add_vertex(vIP); }
553  }
554  }
555 
556 
557  // Path 3
558  { int cuts(0);
559 
560  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v0, v3, vIP, distIP)) {
561 
562  ++cuts;
563 
564 #ifndef AMREX_USE_GPU
565  if (a_dry_run) { Print() << "P3: v0--v3: add vIP to F4, F5 and F7 :: " << vIP[2] << "\n"; }
566  else
567 #endif
568  {
569  m_F4.add_vertex(vIP);
570  m_F5.add_vertex(vIP);
571  m_F7.add_vertex(vIP);
572  }
573 
574  if ( almostEqual(distIP, 0.0)) {
575 #ifndef AMREX_USE_GPU
576  if (a_dry_run) { Print() << "P3: v0--v3: intersection ~ 0 :: add vIP to F1\n"; }
577  else
578 #endif
579  { m_F1.add_vertex(vIP); }
580 
581  } else if ( almostEqual(distIP, 1.0)) {
582 #ifndef AMREX_USE_GPU
583  if (a_dry_run) { Print() << "P3: v0--v3: intersection ~ 1 :: add vIP to F3\n"; }
584  else
585 #endif
586  { m_F3.add_vertex(vIP); }
587  }
588 
589  }
590 
591  if (cuts%2 == 0) {
592 
593 #ifndef AMREX_USE_GPU
594  if (a_dry_run) { Print() << "P3: Add v3 to F3, F4 and F5\n"; }
595  else
596 #endif
597  {
598  m_F3.add_vertex(v3);
599  m_F4.add_vertex(v3);
600  m_F5.add_vertex(v3);
601  }
602  }
603 
604  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v3, v6, vIP, distIP)) {
605 
606  ++cuts;
607 
608 #ifndef AMREX_USE_GPU
609  if (a_dry_run) { Print() << "P3: v3--v6: add vIP to F3, F4 and F7 :: " << vIP[1] << "\n"; }
610  else
611 #endif
612  {
613  m_F3.add_vertex(vIP);
614  m_F4.add_vertex(vIP);
615  m_F7.add_vertex(vIP);
616  }
617 
618  if ( almostEqual(distIP, 0.0)) {
619 #ifndef AMREX_USE_GPU
620  if (a_dry_run) { Print() << "P3: v3--v6: intersection ~ 0 :: add vIP to F5\n"; }
621  else
622 #endif
623  { m_F5.add_vertex(vIP); }
624 
625  } else if ( almostEqual(distIP, 1.0)) {
626 #ifndef AMREX_USE_GPU
627  if (a_dry_run) { Print() << "P3: v3--v6: intersection ~ 1 :: add vIP to F6\n"; }
628  else
629 #endif
630  { m_F6.add_vertex(vIP); }
631  }
632 
633  }
634 
635  if (cuts%2 == 0) {
636 
637 #ifndef AMREX_USE_GPU
638  if (a_dry_run) { Print() << "P3: Add v6 to F3, F4 and F6\n"; }
639  else
640 #endif
641  {
642  m_F3.add_vertex(v6);
643  m_F4.add_vertex(v6);
644  m_F6.add_vertex(v6);
645  }
646  }
647 
648  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v6, v7, vIP, distIP)) {
649 
650  ++cuts;
651 
652 #ifndef AMREX_USE_GPU
653  if (a_dry_run) { Print() << "P3: v6--v7: add vIP to F3, F6 and F7 :: " << vIP[0] << "\n"; }
654  else
655 #endif
656  {
657  m_F3.add_vertex(vIP);
658  m_F6.add_vertex(vIP);
659  m_F7.add_vertex(vIP);
660  }
661 
662  if ( almostEqual(distIP, 0.0)) {
663 #ifndef AMREX_USE_GPU
664  if (a_dry_run) { Print() << "P3: v6--v7: intersection ~ 0 :: add vIP to F4\n"; }
665  else
666 #endif
667  { m_F4.add_vertex(vIP); }
668 
669  } else if ( almostEqual(distIP, 1.0)) {
670 #ifndef AMREX_USE_GPU
671  if (a_dry_run) { Print() << "P3: v6--v7: intersection ~ 1 :: add vIP to F2\n"; }
672  else
673 #endif
674  { m_F2.add_vertex(vIP); }
675  }
676  }
677 
678  if (cuts == 2 && add_v7) {
679 
680 #ifndef AMREX_USE_GPU
681  if (a_dry_run) { Print() << "P1: Add v7 to F2, F3 and F6\n"; }
682  else
683 #endif
684  {
685  m_F2.add_vertex(v7);
686  m_F3.add_vertex(v7);
687  m_F6.add_vertex(v7);
688  }
689  add_v7 = 0;
690  }
691 
692  } // end Path 3
693 
694  if (utils::intersect_plane_edge(m_eb_point, m_eb_normal, v3, v4, vIP, distIP)) {
695 
696 #ifndef AMREX_USE_GPU
697  if (a_dry_run) { Print() << "P6: v3--v4: add vIP to F3, F5 and F7 :: " << vIP[0] << "\n"; }
698  else
699 #endif
700  {
701  m_F3.add_vertex(vIP);
702  m_F5.add_vertex(vIP);
703  m_F7.add_vertex(vIP);
704  }
705 
706  if ( almostEqual(distIP, 0.0)) {
707 #ifndef AMREX_USE_GPU
708  if (a_dry_run) { Print() << "P6: v3--v4: intersection ~ 0 :: add vIP to F4\n"; }
709  else
710 #endif
711  { m_F4.add_vertex(vIP); }
712 
713  } else if ( almostEqual(distIP, 1.0)) {
714 #ifndef AMREX_USE_GPU
715  if (a_dry_run) { Print() << "P6: v3--v4: intersection ~ 1 :: add vIP to F2\n"; }
716  else
717 #endif
718  { m_F2.add_vertex(vIP); }
719  }
720  }
721 }
polygon_::add_vertex
AMREX_GPU_HOST_DEVICE void add_vertex(amrex::RealVect const &a_v)
Definition: ERF_EBPolygon.H:43
utils::intersect_plane_edge
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int intersect_plane_edge(amrex::RealVect const &a_plane_point, amrex::RealVect const &a_plane_normal, amrex::RealVect const &a_edge_point0, amrex::RealVect const &a_edge_point1, amrex::RealVect &a_intersection_point, amrex::Real &a_intersection_dist)
Definition: ERF_EBUtils.H:30

Referenced by eb_cut_cell_().

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)
9  {
10 
11  amrex::Print() << "\n\nDEBUG THIS "
12  << "--------------------------------------"
13  << "\nisCovered? " << isCovered()
14  << "\nisRegular? " << isRegular()
15  << "\nisSingleValued? " << isSingleValued()
16  << "\n";
17 
18  if ( isCovered() || isRegular() ) { return; }
19 
20  amrex::RealVect v0(m_rbox.lo(0), m_rbox.lo(1), m_rbox.lo(2));
21  amrex::RealVect v7(m_rbox.hi(0), m_rbox.hi(1), m_rbox.hi(2));
22 
23  amrex::Print() << "\n"
24  << "lo: " << v0 << '\n'
25  << "hi: " << v7 << '\n'
26  << "p: " << m_eb_point << '\n'
27  << "n: " << m_eb_normal << '\n'
28  << "invert? " << m_invert << "\n\n";
29 
30  int const dry_run(1);
31  amrex::Print() << "Edge intersections:\n";
32  calc_edge_intersections(dry_run);
33  amrex::Print() << '\n';
34 
35  if ( a_face == -1 || a_face == 1 ) { m_F1.report(1, v0); }
36  if ( a_face == -1 || a_face == 2 ) { m_F2.report(2, v0); }
37  if ( a_face == -1 || a_face == 3 ) { m_F3.report(3, v0); }
38  if ( a_face == -1 || a_face == 4 ) { m_F4.report(4, v0); }
39  if ( a_face == -1 || a_face == 5 ) { m_F5.report(5, v0); }
40  if ( a_face == -1 || a_face == 6 ) { m_F6.report(6, v0); }
41  if ( a_face == -1 || a_face == 7 ) { m_F7.report(7, v0); }
42 }
eb_cut_cell_::isRegular
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool isRegular() const noexcept
Definition: ERF_EBCutCell.H:26
eb_cut_cell_::isSingleValued
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool isSingleValued() const noexcept
Definition: ERF_EBCutCell.H:29
eb_cut_cell_::isCovered
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool isCovered() const noexcept
Definition: ERF_EBCutCell.H:23
polygon_::report
void report(int const a_id, amrex::RealVect a_v0)
Definition: ERF_EBPolygon.H:145

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
23 { 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
26 { 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
29 { return m_flag.isSingleValued(); }

◆ set_covered()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::set_covered ( )
inline
32 { m_flag.setCovered(); }

Referenced by eb_cut_cell_().

Here is the caller graph for this function:

◆ set_regular()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void eb_cut_cell_::set_regular ( )
inline
35  {
36 
37  m_flag.setRegular();
38 
39  m_F1.set_area( m_rbox.length(0)*m_rbox.length(1) );
40  m_F3.set_area( m_rbox.length(0)*m_rbox.length(1) );
41 
42  m_F2.set_area( m_rbox.length(1)*m_rbox.length(2) );
43  m_F4.set_area( m_rbox.length(1)*m_rbox.length(2) );
44 
45  m_F5.set_area( m_rbox.length(0)*m_rbox.length(2) );
46  m_F6.set_area( m_rbox.length(0)*m_rbox.length(2) );
47 
48  m_F7.set_area(0.);
49 
50  }
polygon_::set_area
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void set_area(amrex::Real const &a_area)
Definition: ERF_EBPolygon.H:50

Referenced by eb_cut_cell_().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ volume()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real eb_cut_cell_::volume ( )
inline
53  {
54 
55  if (m_flag.isCovered() ) { return 0.; }
56  if (m_flag.isRegular() ) { return m_rbox.volume(); }
57 
58  amrex::Real volume(0.);
59 
60  amrex::Real const* lo = m_rbox.lo();
61  amrex::RealVect v0(lo[0], lo[1], lo[2]);
62 
63  if( m_F2.ok() ) { volume += m_F2.area() * m_F2.distance(v0); }
64  if (m_F3.ok() ) { volume += m_F3.area() * m_F3.distance(v0); }
65  if (m_F6.ok() ) { volume += m_F6.area() * m_F6.distance(v0); }
66  if (m_F7.ok() ) { volume += m_F7.area() * m_F7.distance(v0); }
67 
68  volume /= 3.;
69 
70  return m_invert*volume + (1.-m_invert)*(m_rbox.volume()-volume);
71  }
eb_cut_cell_::volume
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real volume()
Definition: ERF_EBCutCell.H:53
polygon_::ok
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int ok() const noexcept
Definition: ERF_EBPolygon.H:119
polygon_::distance
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real distance(amrex::RealVect const &a_point) const noexcept
Definition: ERF_EBPolygon.H:130
polygon_::area
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real area() const noexcept
Definition: ERF_EBPolygon.H:123

Referenced by eb_aux_::define().

Here is the call graph for this function:
Here is the caller graph for this function:

Member Data Documentation

◆ m_eb_normal

amrex::RealVect const eb_cut_cell_::m_eb_normal
private

Referenced by calc_edge_intersections(), and eb_cut_cell_().

◆ m_eb_point

amrex::RealVect const eb_cut_cell_::m_eb_point
private

Referenced by calc_edge_intersections(), and eb_cut_cell_().

◆ m_F1

polygon_ eb_cut_cell_::m_F1
private

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

◆ m_F2

polygon_ eb_cut_cell_::m_F2
private

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

◆ m_F3

polygon_ eb_cut_cell_::m_F3
private

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

◆ m_F4

polygon_ eb_cut_cell_::m_F4
private

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

◆ m_F5

polygon_ eb_cut_cell_::m_F5
private

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

◆ m_F6

polygon_ eb_cut_cell_::m_F6
private

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

◆ m_F7

polygon_ eb_cut_cell_::m_F7
private

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

◆ m_flag

amrex::EBCellFlag eb_cut_cell_::m_flag
private

Referenced by areaHi(), areaLo(), eb_cut_cell_(), isCovered(), isRegular(), isSingleValued(), 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().

◆ m_invert

amrex::Real eb_cut_cell_::m_invert
private

Referenced by areaHi(), areaLo(), eb_cut_cell_(), 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().

◆ m_rbox

amrex::RealBox const eb_cut_cell_::m_rbox
private

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

◆ m_rbox_area

amrex::RealVect eb_cut_cell_::m_rbox_area
private

Referenced by areaHi(), areaLo(), and eb_cut_cell_().

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