ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Public Member Functions | Private Attributes | List of all members
eb_aux_ Class Reference

#include <ERF_EBAux.H>

Collaboration diagram for eb_aux_:
Collaboration graph
[legend]

Public Member Functions

 eb_aux_ ()
 
 ~eb_aux_ ()
 
void define (int const &a_idim, amrex::Geometry const &a_geom, amrex::BoxArray const &a_grids, amrex::DistributionMapping const &a_dmap, amrex::Vector< int > const &a_ngrow, amrex::EBFArrayBoxFactory const *a_factory)
 
void set_verbose ()
 
const amrex::FabArray< amrex::EBCellFlagFab > & getMultiEBCellFlagFab () const
 
const amrex::MultiFab & getVolFrac () const
 
const amrex::MultiFab & getCentroid () const
 
const amrex::MultiFab & getBndryArea () const
 
const amrex::MultiFab & getBndryCent () const
 
const amrex::MultiFab & getBndryNorm () const
 
amrex::Array< const amrex::MultiFab *, AMREX_SPACEDIM > getAreaFrac () const
 
amrex::Array< const amrex::MultiFab *, AMREX_SPACEDIM > getFaceCent () const
 

Private Attributes

int m_verbose
 
amrex::FabArray< amrex::EBCellFlagFab > * m_cellflags = nullptr
 
amrex::MultiFab * m_volfrac = nullptr
 
amrex::MultiFab * m_volcent = nullptr
 
amrex::MultiFab * m_bndryarea = nullptr
 
amrex::MultiFab * m_bndrycent = nullptr
 
amrex::MultiFab * m_bndrynorm = nullptr
 
amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > m_areafrac {{AMREX_D_DECL(nullptr, nullptr, nullptr)}}
 
amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > m_facecent {{AMREX_D_DECL(nullptr, nullptr, nullptr)}}
 

Constructor & Destructor Documentation

◆ eb_aux_()

eb_aux_::eb_aux_ ( )
13  : m_verbose(0)
14 // ,m_defined(0)
15 {}
eb_aux_::m_verbose
int m_verbose
Definition: ERF_EBAux.H:39

◆ ~eb_aux_()

eb_aux_::~eb_aux_ ( )
8 {
9 }

Member Function Documentation

◆ define()

void eb_aux_::define ( int const &  a_idim,
amrex::Geometry const &  a_geom,
amrex::BoxArray const &  a_grids,
amrex::DistributionMapping const &  a_dmap,
amrex::Vector< int > const &  a_ngrow,
amrex::EBFArrayBoxFactory const *  a_factory 
)
25 {
26  // Box dbox(a_geom.Domain());
27 
28  const IntVect vdim(IntVect::TheDimensionVector(a_idim));
29 
30  const BoxArray& grids = amrex::convert(a_grids, vdim);
31 
32  m_cellflags = new FabArray<EBCellFlagFab>(grids, a_dmap, 1, a_ngrow[0], MFInfo(),
33  DefaultFabFactory<EBCellFlagFab>());
34 
35  // Set m_cellflags type to singlevalued
36  m_cellflags->setVal(EBCellFlag::TheDefaultCell());
37  for (MFIter mfi(*m_cellflags, false); mfi.isValid(); ++mfi) {
38  auto& fab = (*m_cellflags)[mfi];
39  fab.setType(FabType::singlevalued);
40  }
41 
42  m_volfrac = new MultiFab(grids, a_dmap, 1, a_ngrow[1], MFInfo(), FArrayBoxFactory());
43  m_volcent = new MultiFab(grids, a_dmap, AMREX_SPACEDIM, a_ngrow[2], MFInfo(), FArrayBoxFactory());
44 
45  for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
46  const BoxArray& faceba = amrex::convert(a_grids, IntVect::TheDimensionVector(idim));
47  m_areafrac[idim] = new MultiFab(faceba, a_dmap, 1, a_ngrow[2], MFInfo(), FArrayBoxFactory());
48  m_facecent[idim] = new MultiFab(faceba, a_dmap, AMREX_SPACEDIM-1, a_ngrow[2], MFInfo(), FArrayBoxFactory());
49  }
50 
51  m_bndryarea = new MultiFab(grids, a_dmap, 1, a_ngrow[2], MFInfo(), FArrayBoxFactory());
52  m_bndrycent = new MultiFab(grids, a_dmap, AMREX_SPACEDIM, a_ngrow[2], MFInfo(), FArrayBoxFactory());
53  m_bndrynorm = new MultiFab(grids, a_dmap, AMREX_SPACEDIM, a_ngrow[2], MFInfo(), FArrayBoxFactory());
54 
55  // Initialize with zeros
56  m_volfrac->setVal(0.0);
57  m_volcent->setVal(0.0);
58  for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
59  m_areafrac[idim]->setVal(0.0);
60  m_facecent[idim]->setVal(0.0);
61  }
62  m_bndryarea->setVal(0.0);
63  m_bndrycent->setVal(0.0);
64  m_bndrynorm->setVal(0.0);
65 
66  const auto& FlagFab = a_factory->getMultiEBCellFlagFab(); // EBFArrayBoxFactory, EBDataCollection
67 
68  for (MFIter mfi(*m_cellflags, false); mfi.isValid(); ++mfi) {
69 
70  const Box& bx = mfi.validbox();
71  const Box domain = surroundingNodes(a_geom.Domain(), a_idim);
72 
73  if (FlagFab[mfi].getType(bx) == FabType::singlevalued ) {
74 
75  GpuArray<Real, AMREX_SPACEDIM> dx = a_geom.CellSizeArray();
76 
77  Array4<EBCellFlag const> const& flag = FlagFab.const_array(mfi);
78 
79  // Array4<Real const> const& vfrac = (a_factory->getVolFrac()).const_array(mfi);
80  // Array4<Real const> const& ccent = (a_factory->getCentroid()).const_array(mfi);
81  // Array4<Real const> const& afrac = (a_factory->getAreaFrac()[a_idim])->const_array(mfi);
82 
83  // EB normal and face centroid
84  Array4<Real const> const& bnorm = a_factory->getBndryNormal()[mfi].const_array();
85  Array4<Real const> const& bcent = a_factory->getBndryCent()[mfi].const_array();
86 
87  // aux quantities
88  Array4<EBCellFlag> const& aux_flag = m_cellflags->array(mfi);
89  Array4<Real> const& aux_vfrac = m_volfrac->array(mfi);
90  Array4<Real> const& aux_vcent = m_volcent->array(mfi);
91 
92  Array4<Real> const& aux_afrac_x = m_areafrac[0]->array(mfi);
93  Array4<Real> const& aux_afrac_y = m_areafrac[1]->array(mfi);
94  Array4<Real> const& aux_afrac_z = m_areafrac[2]->array(mfi);
95 
96  Array4<Real> const& aux_fcent_x = m_facecent[0]->array(mfi);
97  Array4<Real> const& aux_fcent_y = m_facecent[1]->array(mfi);
98  Array4<Real> const& aux_fcent_z = m_facecent[2]->array(mfi);
99 
100  Array4<Real> const& aux_barea = m_bndryarea->array(mfi);
101  Array4<Real> const& aux_bcent = m_bndrycent->array(mfi);
102  Array4<Real> const& aux_bnorm = m_bndrynorm->array(mfi);
103 
104  bool is_per = a_geom.isPeriodic(a_idim);
105 
106  ParallelFor(bx, [
107 #ifndef AMREX_USE_GPU
108  verbose=m_verbose,
109 #endif
110  dx, bx, domain, bnorm, bcent, flag,
111  aux_flag, aux_vfrac, aux_vcent,
112  aux_afrac_x, aux_afrac_y, aux_afrac_z,
113  aux_fcent_x, aux_fcent_y, aux_fcent_z,
114  aux_barea, aux_bcent, aux_bnorm,
115  vdim, idim=a_idim, is_per ]
116  AMREX_GPU_DEVICE (int i, int j, int k) noexcept
117  {
118 
119  // defaults to covered and disconnected.
120 
121  aux_flag(i,j,k).setCovered();
122  aux_flag(i,j,k).setDisconnected();
123 
124  aux_vfrac(i,j,k) = 0.0;
125  aux_vcent(i,j,k,0) = 0.0;
126  aux_vcent(i,j,k,1) = 0.0;
127  aux_vcent(i,j,k,2) = 0.0;
128 
129  aux_afrac_x(i,j,k) = 0.0;
130  aux_afrac_y(i,j,k) = 0.0;
131  aux_afrac_z(i,j,k) = 0.0;
132 
133  aux_fcent_x(i,j,k,0) = 0.0; aux_fcent_x(i,j,k,1) = 0.0;
134  aux_fcent_y(i,j,k,0) = 0.0; aux_fcent_y(i,j,k,1) = 0.0;
135  aux_fcent_z(i,j,k,0) = 0.0; aux_fcent_z(i,j,k,1) = 0.0;
136 
137  if (i==bx.bigEnd(0)) {
138  aux_afrac_x(i+1,j,k) = 0.0;
139  aux_fcent_x(i+1,j,k,0) = 0.0;
140  aux_fcent_x(i+1,j,k,1) = 0.0;
141  }
142  if (j==bx.bigEnd(1)) {
143  aux_afrac_y(i,j+1,k) = 0.0;
144  aux_fcent_y(i,j+1,k,0) = 0.0;
145  aux_fcent_y(i,j+1,k,1) = 0.0;
146  }
147  if (k==bx.bigEnd(2)) {
148  aux_afrac_z(i,j,k+1) = 0.0;
149  aux_fcent_z(i,j,k+1,0) = 0.0;
150  aux_fcent_z(i,j,k+1,1) = 0.0;
151  }
152 
153  aux_barea(i,j,k) = 0.0;
154 
155  aux_bcent(i,j,k,0) = 0.0;
156  aux_bcent(i,j,k,1) = 0.0;
157  aux_bcent(i,j,k,2) = 0.0;
158 
159  aux_bnorm(i,j,k,0) = 0.0;
160  aux_bnorm(i,j,k,1) = 0.0;
161  aux_bnorm(i,j,k,2) = 0.0;
162 
163  // Index for low and hi cells
164  IntVect iv_hi(i,j,k);
165  IntVect iv_lo(iv_hi - vdim);
166  if (!is_per && iv_hi[idim]==domain.bigEnd(idim)){
167  iv_hi = iv_lo; // At the upper boundary, hi cell takes the values of the low cell.
168  }
169  if (!is_per && iv_hi[idim]==domain.smallEnd(idim)){
170  iv_lo = iv_hi; // At the lower boundary, low cell takes the values of the high cell.
171  }
172 
173  if ( flag(iv_lo).isCovered() && flag(iv_hi).isCovered()) {
174 
175  // defaults to covered and disconnected.
176 
177  } else if ( flag(iv_lo).isRegular() && flag(iv_hi).isRegular()) {
178 
179  aux_flag(i,j,k).setRegular();
180 
181  aux_vfrac(i,j,k) = 1.0;
182 
183  aux_afrac_x(i,j,k) = 1.0;
184  aux_afrac_y(i,j,k) = 1.0;
185  aux_afrac_z(i,j,k) = 1.0;
186 
187  aux_fcent_x(i,j,k,0) = 0.0; aux_fcent_x(i,j,k,1) = 0.0;
188  aux_fcent_y(i,j,k,0) = 0.0; aux_fcent_y(i,j,k,1) = 0.0;
189  aux_fcent_z(i,j,k,0) = 0.0; aux_fcent_z(i,j,k,1) = 0.0;
190 
191  if (i==bx.bigEnd(0)) {
192  aux_afrac_x(i+1,j,k) = 1.0;
193  aux_fcent_x(i+1,j,k,0) = 0.0;
194  aux_fcent_x(i+1,j,k,1) = 0.0;
195  }
196  if (j==bx.bigEnd(1)) {
197  aux_afrac_y(i,j+1,k) = 1.0;
198  aux_fcent_y(i,j+1,k,0) = 0.0;
199  aux_fcent_y(i,j+1,k,1) = 0.0;
200  }
201  if (k==bx.bigEnd(2)) {
202  aux_afrac_z(i,j,k+1) = 1.0;
203  aux_fcent_z(i,j,k+1,0) = 0.0;
204  aux_fcent_z(i,j,k+1,1) = 0.0;
205  }
206 
207  } else {
208 
209 #ifndef AMREX_USE_GPU
210  if (verbose) { Print() << "\ncell: " << amrex::IntVect(i,j,k) << "\n"; }
211 #endif
212  Array<Real,AMREX_SPACEDIM> lo_arr = {-0.5,-0.5,-0.5};
213  Array<Real,AMREX_SPACEDIM> hi_arr = { 0.5, 0.5, 0.5};
214 
215  //-----------------------
216  // Low EB cut cell
217  //-----------------------
218 
219  // Map bcent and bnorm to the isoparametric space for anisotropic grids.
220  // (This step is needed because bcent in AMReX is isotropically normalized.)
221 
222  RealVect lo_point (bcent(iv_lo,0), bcent(iv_lo,1), bcent(iv_lo,2));
223  RealVect lo_normal(bnorm(iv_lo,0), bnorm(iv_lo,1), bnorm(iv_lo,2));
224 
225  if (!is_per && iv_hi[idim]==domain.smallEnd(idim)){
226  lo_point[idim] += 1.0; // Move the boundary centroid upward in the idim direction.
227  }
228 
229  if (flag(iv_lo).isSingleValued() ) {
230 
231  Real bnorm_x = bnorm(iv_lo,0) * dx[0];
232  Real bnorm_y = bnorm(iv_lo,1) * dx[1];
233  Real bnorm_z = bnorm(iv_lo,2) * dx[2];
234 
235  Real norm = sqrt( bnorm_x*bnorm_x + bnorm_y*bnorm_y + bnorm_z*bnorm_z);
236 
237  RealVect bnorm_isoparam ( bnorm_x / norm, bnorm_y / norm, bnorm_z / norm);
238 
239  // plane point and normal
240  // lo_point = bcent_isoparam;
241  lo_normal = bnorm_isoparam;
242 
243  }
244 
245  // High side of low cell
246  lo_arr[idim] = 0.0;
247  hi_arr[idim] = 0.5;
248  RealBox lo_rbx(lo_arr.data(), hi_arr.data());
249 
250  eb_cut_cell_ lo_eb_cc(flag(iv_lo), lo_rbx, lo_point, lo_normal);
251 
252  // cell iv_lo covered (regular) imples lo_eb_cc is covered (regular)
253  // The inverse is not always true.
254  AMREX_ASSERT( !flag(iv_lo).isCovered() || lo_eb_cc.isCovered() );
255  AMREX_ASSERT( !flag(iv_lo).isRegular() || lo_eb_cc.isRegular() );
256 
257  //-----------------------
258  // High EB cut cell
259  //-----------------------
260 
261  RealVect hi_point (bcent(iv_hi,0), bcent(iv_hi,1), bcent(iv_hi,2));
262  RealVect hi_normal(bnorm(iv_hi,0), bnorm(iv_hi,1), bnorm(iv_hi,2));
263 
264  if (!is_per && iv_hi[idim]==domain.bigEnd(idim)){
265  lo_point[idim] += -1.0; // Move the boundary centroid downward in the idim direction.
266  }
267 
268  if (flag(iv_hi).isSingleValued() ) {
269 
270  Real bnorm_x = bnorm(iv_hi,0) * dx[0];
271  Real bnorm_y = bnorm(iv_hi,1) * dx[1];
272  Real bnorm_z = bnorm(iv_hi,2) * dx[2];
273 
274  Real norm = sqrt( bnorm_x*bnorm_x + bnorm_y*bnorm_y + bnorm_z*bnorm_z);
275 
276  RealVect bnorm_isoparam ( bnorm_x / norm, bnorm_y / norm, bnorm_z / norm);
277 
278  // plane point and normal
279  // hi_point = bcent_isoparam;
280  hi_normal = bnorm_isoparam;
281 
282  }
283 
284  // Low side of high cell
285  lo_arr[idim] = -0.5;
286  hi_arr[idim] = 0.0;
287  RealBox hi_rbx(lo_arr.data(), hi_arr.data());
288 
289  eb_cut_cell_ hi_eb_cc(flag(iv_hi), hi_rbx, hi_point, hi_normal);
290 
291  // cell iv_hi covered (regular) imples hi_eb_cc is covered (regular)
292  // The inverse is not always true.
293  AMREX_ASSERT( !flag(iv_hi).isCovered() || hi_eb_cc.isCovered() );
294  AMREX_ASSERT( !flag(iv_hi).isRegular() || hi_eb_cc.isRegular() );
295 
296 #if 0
297 #if defined(AMREX_DEBUG) || defined(AMREX_TESTING) || 1
298 
299  { /***************************** SANITY CHECK ***********************\
300  * Perform some basic sanity checks to verify that what we computed *
301  * for cell (i,j,k) compares to what we know to be true. *
302  \******************************************************************/
303 
304  // Compute the cut-cell for the high side of the high cell. This is
305  // only needed for sanity checks.
306 
307  eb_cut_cell_ hi_hi_eb_cc(flag(iv_hi), lo_rbx, hi_point, hi_normal);
308 
309  // cell iv_hi covered (regular) imples hi_hi_eb_cc is covered (regular)
310  // The inverse is not always true.
311 #ifndef AMREX_USE_GPU
312  if ( !(!flag(iv_hi).isRegular() || hi_hi_eb_cc.isRegular()) ||
313  !(!flag(iv_hi).isCovered() || hi_hi_eb_cc.isCovered()) ) {
314  Print() << "flag(iv_hi) and hi_hi_eb_cc flags do not agree\n"
315  << "\n isRegular() " << flag(iv_hi).isRegular() << " " << hi_hi_eb_cc.isRegular()
316  << "\n isCovered() " << flag(iv_hi).isCovered() << " " << hi_hi_eb_cc.isCovered()
317  << "\n";
318  }
319 #endif
320  // If cell iv_hi is regular or covered, then hi_hi_eb_cc must also
321  // be regular or covered. The inverse is not true.
322  AMREX_ALWAYS_ASSERT( !flag(iv_hi).isRegular() || hi_hi_eb_cc.isRegular() );
323  AMREX_ALWAYS_ASSERT( !flag(iv_hi).isCovered() || hi_hi_eb_cc.isCovered() );
324 
325  // The area and volume fractions that are computed for the scalar grid
326  // are slightly different than those we compute from the geometric
327  // reconstruction using the EB point and normal. However, we expect
328  // that the area fractions computed here will give back the same
329  // normal we used to compute them.
330  if ( flag(iv_hi).isSingleValued() ) {
331 
332  Real const adx = (idim == 0)
333  ? (hi_eb_cc.areaLo(0) - hi_hi_eb_cc.areaHi(0)) * dx[1] * dx[2]
334  : (hi_eb_cc.areaLo(0) + hi_hi_eb_cc.areaLo(0)) * dx[1] * dx[2]
335  - (hi_eb_cc.areaHi(0) + hi_hi_eb_cc.areaHi(0)) * dx[1] * dx[2];
336 
337  Real const ady = (idim == 1)
338  ? (hi_eb_cc.areaLo(1) - hi_hi_eb_cc.areaHi(1)) * dx[0] * dx[2]
339  : (hi_eb_cc.areaLo(1) + hi_hi_eb_cc.areaLo(1)) * dx[0] * dx[2]
340  - (hi_eb_cc.areaHi(1) + hi_hi_eb_cc.areaHi(1)) * dx[0] * dx[2];
341 
342  Real const adz = (idim == 2)
343  ? (hi_eb_cc.areaLo(2) - hi_hi_eb_cc.areaHi(2)) * dx[0] * dx[1]
344  : (hi_eb_cc.areaLo(2) + hi_hi_eb_cc.areaLo(2)) * dx[0] * dx[1]
345  - (hi_eb_cc.areaHi(2) + hi_hi_eb_cc.areaHi(2)) * dx[0] * dx[1];
346 
347  Real const apnorm = std::sqrt(adx*adx + ady*ady + adz*adz);
348 
349  // EB normal
350  Real const apnorminv = 1. / apnorm;
351  RealVect const normal(adx*apnorminv, ady*apnorminv, adz*apnorminv);
352  Real const dot_normals = normal.dotProduct(hi_normal);
353 
354 #ifndef AMREX_USE_GPU
355  if ( !amrex::almostEqual(dot_normals, 1.0) ) {
356  Print() << "\nFail: check-1 dot_normals " << dot_normals
357  << '\n';
358 
359  hi_eb_cc.debug();
360  hi_hi_eb_cc.debug();
361 
362  } else if (verbose) {
363  Print() << "Pass: dot_normals = 1.0\n";
364 
365  }
366 #endif
367  AMREX_ALWAYS_ASSERT( amrex::almostEqual(dot_normals, 1.0) );
368  }
369 
370  // The idim area of hi_eb_cc.areaHi() should equal hi_hi_eb_cc.areaLo()
371  {
372 #ifndef AMREX_USE_GPU
373  Real const abs_err = std::abs( hi_eb_cc.areaHi(idim) - hi_hi_eb_cc.areaLo(idim) );
374  Real machine_tol = 10.0*std::numeric_limits<amrex::Real>::epsilon();
375  if ( abs_err >= machine_tol ) {
376  Print() << "\nFail: check-2 area abs_err: " << abs_err
377  << "\n hi_eb_cc.areaHi " << hi_eb_cc.areaHi(idim)
378  << "\n hi_hi_eb_cc.areaLo " << hi_hi_eb_cc.areaLo(idim)
379  << '\n';
380  } else if (verbose) {
381  Print() << "Pass: hi_eb_cc.areaHi = hi_hi_eb_cc.areaLo"
382  << " abs_err: " << abs_err << "\n";
383  }
384  AMREX_ALWAYS_ASSERT( abs_err < machine_tol );
385 #endif
386  }
387 
388  // The low-side area of hi_eb_cc should equal idim afrac.
389  { Real const abs_err = amrex::max(std::abs(lo_eb_cc.areaHi(idim) - afrac(iv_hi)),
390  std::abs(hi_eb_cc.areaLo(idim) - afrac(iv_hi)));
391  Real compare_tol = 5.0e-6;
392 #ifndef AMREX_USE_GPU
393  if ( abs_err >= compare_tol ) {
394  //hi_eb_cc.debug();
395  Print() << "\nFail: check-3 area abs_err " << abs_err
396  << "\n hi_eb_cc.areaLo(" << idim << ") = " << hi_eb_cc.areaLo(idim)
397  << "\n lo_eb_cc.areaHi(" << idim << ") = " << lo_eb_cc.areaHi(idim)
398  << "\n afrac" << iv_hi << " = " << afrac(iv_hi)
399  << '\n';
400  } else if (verbose) {
401  Print() << "Pass: hi_eb_cc.areaLo = afrac = " << afrac(iv_hi)
402  << " abs_err: " << abs_err << "\n";
403  }
404 #endif
405  AMREX_ALWAYS_ASSERT( abs_err < compare_tol );
406  }
407 
408  // The combined volumes of hi_eb_cc.areaHi() and hi_hi_eb_cc should
409  // equal vfrac(iv_hi).
410  { Real const vol = hi_eb_cc.volume() + hi_hi_eb_cc.volume();
411  Real const abs_err = amrex::Math::abs(vfrac(iv_hi) - vol);
412  Real compare_tol = 5.0e-6;
413 #ifndef AMREX_USE_GPU
414  if ( abs_err >= compare_tol ) {
415  hi_eb_cc.debug();
416  hi_hi_eb_cc.debug();
417  amrex::Print() << "\nFail: check-4 volume abs_err: " << abs_err
418  << "\n point: " << hi_point
419  << "\n normal: " << hi_normal
420  << "\n hi_eb_cc.volume() " << hi_eb_cc.volume()
421  << "\n hi_hi_eb_cc.volume() " << hi_hi_eb_cc.volume()
422  << "\n vfrac: " << vfrac(iv_hi)
423  << '\n';
424  } else if (verbose) {
425  Print() << "Pass: hi_eb_cc + hi_hi_eb_cc = vfrac = " << vfrac(iv_hi)
426  << " abs_err: " << abs_err << "\n";
427  }
428 #endif
429  AMREX_ALWAYS_ASSERT( abs_err < compare_tol );
430  }
431  } //
432 #endif
433 #endif // 0
434 
435  //-----------------------
436  // Fill out aux_ arrays
437  //-----------------------
438 
439  if (lo_eb_cc.isCovered() && hi_eb_cc.isCovered()) {
440 
441  // defaults to covered and disconnected.
442 
443  } else if (lo_eb_cc.isRegular() && hi_eb_cc.isRegular()) {
444 
445  aux_flag(i,j,k).setRegular();
446 
447  aux_vfrac(i,j,k) = 1.0;
448 
449  aux_afrac_x(i,j,k) = 1.0;
450  aux_afrac_y(i,j,k) = 1.0;
451  aux_afrac_z(i,j,k) = 1.0;
452 
453  aux_fcent_x(i,j,k,0) = 0.0; aux_fcent_x(i,j,k,1) = 0.0;
454  aux_fcent_y(i,j,k,0) = 0.0; aux_fcent_y(i,j,k,1) = 0.0;
455  aux_fcent_z(i,j,k,0) = 0.0; aux_fcent_z(i,j,k,1) = 0.0;
456 
457  if (i==bx.bigEnd(0)) {
458  aux_afrac_x(i+1,j,k) = 1.0;
459  aux_fcent_x(i+1,j,k,0) = 0.0; aux_fcent_x(i+1,j,k,1) = 0.0;
460  }
461  if (j==bx.bigEnd(1)) {
462  aux_afrac_y(i,j+1,k) = 1.0;
463  aux_fcent_y(i,j+1,k,0) = 0.0; aux_fcent_y(i,j+1,k,1) = 0.0;
464  }
465  if (k==bx.bigEnd(2)) {
466  aux_afrac_z(i,j,k+1) = 1.0;
467  aux_fcent_z(i,j,k+1,0) = 0.0; aux_fcent_z(i,j,k+1,1) = 0.0;
468  }
469 
470  } else if ( (lo_eb_cc.isRegular() && hi_eb_cc.isCovered())
471  || (lo_eb_cc.isCovered() && hi_eb_cc.isRegular()) ) {
472 
473  // This is a problematic situation.
474 #ifndef AMREX_USE_GPU
475  Print()<< "eb_aux_ / Check: Regular and Covered cut cells are facing each other." << std::endl;
476 #endif
477 
478  } else {
479 
480  aux_flag(i,j,k).setSingleValued();
481 
482  // 1. Volume Fraction
483 
484  Real lo_vol {lo_eb_cc.volume()};
485  Real hi_vol {hi_eb_cc.volume()};
486 
487  aux_vfrac(i,j,k) = lo_vol + hi_vol;
488 
489  // 2. Volume Centroid
490 
491  /* centVol() returns the coordinates based on m_rbx.
492  The coordinates in the idim direction are in [0.0,0.5] for the low cell and in [-0.5,0.0] for the hi cell.
493  Therefore, they need to be mapped to the eb_aux space, by shifting:
494  x' = x - 0.5 (low cell), x + 0.5 (hi cell) if idim = 0
495  y' = y - 0.5 (low cell), y + 0.5 (hi cell) if idim = 1
496  z' = z - 0.5 (low cell), z + 0.5 (hi cell) if idim = 2
497  */
498 
499  RealVect lo_vcent {lo_eb_cc.centVol()};
500  RealVect hi_vcent {hi_eb_cc.centVol()};
501 
502  lo_vcent[idim] = lo_vcent[idim] - 0.5;
503  hi_vcent[idim] = hi_vcent[idim] + 0.5;
504 
505  aux_vcent(i,j,k,0) = ( lo_vol * lo_vcent[0] + hi_vol * hi_vcent[0] ) / aux_vfrac(i,j,k);
506  aux_vcent(i,j,k,1) = ( lo_vol * lo_vcent[1] + hi_vol * hi_vcent[1] ) / aux_vfrac(i,j,k);
507  aux_vcent(i,j,k,2) = ( lo_vol * lo_vcent[2] + hi_vol * hi_vcent[2] ) / aux_vfrac(i,j,k);
508 
509  // 3. Area Fraction
510 
511  Real lo_areaLo_x {lo_eb_cc.areaLo(0)};
512  Real lo_areaLo_y {lo_eb_cc.areaLo(1)};
513  Real lo_areaLo_z {lo_eb_cc.areaLo(2)};
514 
515  Real hi_areaLo_x {hi_eb_cc.areaLo(0)};
516  Real hi_areaLo_y {hi_eb_cc.areaLo(1)};
517  Real hi_areaLo_z {hi_eb_cc.areaLo(2)};
518 
519  aux_afrac_x(i,j,k) = (idim == 0) ? lo_areaLo_x : lo_areaLo_x + hi_areaLo_x;
520  aux_afrac_y(i,j,k) = (idim == 1) ? lo_areaLo_y : lo_areaLo_y + hi_areaLo_y;
521  aux_afrac_z(i,j,k) = (idim == 2) ? lo_areaLo_z : lo_areaLo_z + hi_areaLo_z;
522 
523  if (i==bx.bigEnd(0)) {
524  Real lo_areaHi_x {lo_eb_cc.areaHi(0)};
525  Real hi_areaHi_x {hi_eb_cc.areaHi(0)};
526  aux_afrac_x(i+1,j,k) = (idim == 0) ? hi_areaHi_x : lo_areaHi_x + hi_areaHi_x;
527  }
528  if (j==bx.bigEnd(1)) {
529  Real lo_areaHi_y {lo_eb_cc.areaHi(1)};
530  Real hi_areaHi_y {hi_eb_cc.areaHi(1)};
531  aux_afrac_y(i,j+1,k) = (idim == 1) ? hi_areaHi_y : lo_areaHi_y + hi_areaHi_y;
532  }
533  if (k==bx.bigEnd(2)) {
534  Real lo_areaHi_z {lo_eb_cc.areaHi(2)};
535  Real hi_areaHi_z {hi_eb_cc.areaHi(2)};
536  aux_afrac_z(i,j,k+1) = (idim == 2) ? hi_areaHi_z : lo_areaHi_z + hi_areaHi_z;
537  }
538 
539  // 4. Face Centroid
540 
541  /* fcentLo returns the coordinates based on m_rbx.
542  The coordinates in the idim direction are in [0.0,0.5] for the low cell and in [-0.5,0.0] for the hi cell.
543  Therefore, they need to be mapped to the eb_aux space, by shifting:
544  x' = x - 0.5 (low cell), x + 0.5 (hi cell) if idim = 0
545  y' = y - 0.5 (low cell), y + 0.5 (hi cell) if idim = 1
546  z' = z - 0.5 (low cell), z + 0.5 (hi cell) if idim = 2
547  */
548 
549  RealVect lo_centLo_x {lo_eb_cc.centLo(0)};
550  RealVect lo_centLo_y {lo_eb_cc.centLo(1)};
551  RealVect lo_centLo_z {lo_eb_cc.centLo(2)};
552 
553  RealVect hi_centLo_x {hi_eb_cc.centLo(0)};
554  RealVect hi_centLo_y {hi_eb_cc.centLo(1)};
555  RealVect hi_centLo_z {hi_eb_cc.centLo(2)};
556 
557  if (idim == 0) {
558  aux_fcent_x(i,j,k,0) = lo_centLo_x[1]; // y
559  aux_fcent_x(i,j,k,1) = lo_centLo_x[2]; // z
560  aux_fcent_y(i,j,k,0) = (aux_afrac_y(i,j,k) > 0.0) // x (mapped)
561  ? ( lo_areaLo_y * (lo_centLo_y[0] - 0.5)
562  + hi_areaLo_y * (hi_centLo_y[0] + 0.5) ) / aux_afrac_y(i,j,k)
563  : 0.0;
564  aux_fcent_y(i,j,k,1) = (aux_afrac_y(i,j,k) > 0.0) // z
565  ? ( lo_areaLo_y * lo_centLo_y[2]
566  + hi_areaLo_y * hi_centLo_y[2] ) / aux_afrac_y(i,j,k)
567  : 0.0;
568  aux_fcent_z(i,j,k,0) = (aux_afrac_z(i,j,k) > 0.0) // x (mapped)
569  ? ( lo_areaLo_z * (lo_centLo_z[0] - 0.5)
570  + hi_areaLo_z * (hi_centLo_z[0] + 0.5) ) / aux_afrac_z(i,j,k)
571  : 0.0;
572  aux_fcent_z(i,j,k,1) = (aux_afrac_z(i,j,k) > 0.0) // y
573  ? ( lo_areaLo_z * lo_centLo_z[1]
574  + hi_areaLo_z * hi_centLo_z[1] ) / aux_afrac_z(i,j,k)
575  : 0.0;
576  } else if (idim == 1) {
577  aux_fcent_x(i,j,k,0) = (aux_afrac_x(i,j,k) > 0.0) // y (mapped)
578  ? ( lo_areaLo_x * (lo_centLo_x[1] - 0.5)
579  + hi_areaLo_x * (hi_centLo_x[1] + 0.5) ) / aux_afrac_x(i,j,k)
580  : 0.0;
581  aux_fcent_x(i,j,k,1) = (aux_afrac_x(i,j,k) > 0.0) // z
582  ? ( lo_areaLo_x * lo_centLo_x[2]
583  + hi_areaLo_x * hi_centLo_x[2] ) / aux_afrac_x(i,j,k)
584  : 0.0;
585  aux_fcent_y(i,j,k,0) = lo_centLo_y[0]; // x
586  aux_fcent_y(i,j,k,1) = lo_centLo_y[2]; // z
587  aux_fcent_z(i,j,k,0) = (aux_afrac_z(i,j,k) > 0.0) // x
588  ? ( lo_areaLo_z * lo_centLo_z[0]
589  + hi_areaLo_z * hi_centLo_z[0] ) / aux_afrac_z(i,j,k)
590  : 0.0;
591  aux_fcent_z(i,j,k,1) = (aux_afrac_z(i,j,k) > 0.0) // y (mapped)
592  ? ( lo_areaLo_z * (lo_centLo_z[1] - 0.5)
593  + hi_areaLo_z * (hi_centLo_z[1] + 0.5) ) / aux_afrac_z(i,j,k)
594  : 0.0;
595  } else if (idim == 2) {
596  aux_fcent_x(i,j,k,0) = (aux_afrac_x(i,j,k) > 0.0) // y
597  ? ( lo_areaLo_x * lo_centLo_x[1]
598  + hi_areaLo_x * hi_centLo_x[1] ) / aux_afrac_x(i,j,k)
599  : 0.0;
600  aux_fcent_x(i,j,k,1) = (aux_afrac_x(i,j,k) > 0.0) // z (mapped)
601  ? ( lo_areaLo_x * (lo_centLo_x[2] - 0.5)
602  + hi_areaLo_x * (hi_centLo_x[2] + 0.5) ) / aux_afrac_x(i,j,k)
603  : 0.0;
604  aux_fcent_y(i,j,k,0) = (aux_afrac_y(i,j,k) > 0.0) // x
605  ? ( lo_areaLo_y * lo_centLo_y[0]
606  + hi_areaLo_y * hi_centLo_y[0] ) / aux_afrac_y(i,j,k)
607  : 0.0;
608  aux_fcent_y(i,j,k,1) = (aux_afrac_y(i,j,k) > 0.0) // z (mapped)
609  ? ( lo_areaLo_y * (lo_centLo_y[2] - 0.5)
610  + hi_areaLo_y * (hi_centLo_y[2] + 0.5) ) / aux_afrac_y(i,j,k)
611  : 0.0;
612  aux_fcent_z(i,j,k,0) = lo_centLo_z[0]; // x
613  aux_fcent_z(i,j,k,1) = lo_centLo_z[1]; // y
614  }
615 
616  if (i==bx.bigEnd(0)) {
617  Real lo_areaHi_x {lo_eb_cc.areaHi(0)};
618  Real hi_areaHi_x {hi_eb_cc.areaHi(0)};
619  RealVect lo_centHi_x {lo_eb_cc.centHi(0)};
620  RealVect hi_centHi_x {hi_eb_cc.centHi(0)};
621  if (idim == 0) {
622  aux_fcent_x(i+1,j,k,0) = hi_centHi_x[1]; // y
623  aux_fcent_x(i+1,j,k,1) = hi_centHi_x[2]; // z
624  } else if (idim == 1) {
625  aux_fcent_x(i+1,j,k,0) = (aux_afrac_x(i+1,j,k) > 0.0) // y (mapped)
626  ? ( lo_areaHi_x * (lo_centHi_x[1] - 0.5)
627  + hi_areaHi_x * (hi_centHi_x[1] + 0.5) ) / aux_afrac_x(i+1,j,k)
628  : 0.0;
629  aux_fcent_x(i+1,j,k,1) = (aux_afrac_x(i+1,j,k) > 0.0) // z
630  ? ( lo_areaHi_x * lo_centHi_x[2]
631  + hi_areaHi_x * hi_centHi_x[2] ) / aux_afrac_x(i+1,j,k)
632  : 0.0;
633  } else if (idim == 2) {
634  aux_fcent_x(i+1,j,k,0) = (aux_afrac_x(i+1,j,k) > 0.0) // y
635  ? ( lo_areaHi_x * lo_centHi_x[1]
636  + hi_areaHi_x * hi_centHi_x[1] ) / aux_afrac_x(i+1,j,k)
637  : 0.0;
638  aux_fcent_x(i+1,j,k,1) = (aux_afrac_x(i+1,j,k) > 0.0) // z (mapped)
639  ? ( lo_areaHi_x * (lo_centHi_x[2] - 0.5)
640  + hi_areaHi_x * (hi_centHi_x[2] + 0.5) ) / aux_afrac_x(i+1,j,k)
641  : 0.0;
642  }
643  }
644  if (j==bx.bigEnd(1)) {
645  Real lo_areaHi_y {lo_eb_cc.areaHi(1)};
646  Real hi_areaHi_y {hi_eb_cc.areaHi(1)};
647  RealVect lo_centHi_y {lo_eb_cc.centHi(1)};
648  RealVect hi_centHi_y {hi_eb_cc.centHi(1)};
649  if (idim == 0) {
650  aux_fcent_y(i,j+1,k,0) = (aux_afrac_y(i,j+1,k) > 0.0) // x (mapped)
651  ? ( lo_areaHi_y * (lo_centHi_y[0] - 0.5)
652  + hi_areaHi_y * (hi_centHi_y[0] + 0.5) ) / aux_afrac_y(i,j+1,k)
653  : 0.0;
654  aux_fcent_y(i,j+1,k,1) = (aux_afrac_y(i,j+1,k) > 0.0) // z
655  ? ( lo_areaHi_y * lo_centHi_y[2]
656  + hi_areaHi_y * hi_centHi_y[2] ) / aux_afrac_y(i,j+1,k)
657  : 0.0;
658  } else if (idim == 1) {
659  aux_fcent_y(i,j+1,k,0) = lo_centHi_y[0]; // x
660  aux_fcent_y(i,j+1,k,1) = lo_centHi_y[2]; // z
661  } else if (idim == 2) {
662  aux_fcent_y(i,j+1,k,0) = (aux_afrac_y(i,j+1,k) > 0.0) // x
663  ? ( lo_areaHi_y * lo_centHi_y[0]
664  + hi_areaHi_y * hi_centHi_y[0] ) / aux_afrac_y(i,j+1,k)
665  : 0.0;
666  aux_fcent_y(i,j+1,k,1) = (aux_afrac_y(i,j+1,k) > 0.0) // z (mapped)
667  ? ( lo_areaHi_y * (lo_centHi_y[2] - 0.5)
668  + hi_areaHi_y * (hi_centHi_y[2] + 0.5) ) / aux_afrac_y(i,j+1,k)
669  : 0.0;
670  }
671  }
672  if (k==bx.bigEnd(2)) {
673  Real lo_areaHi_z {lo_eb_cc.areaHi(2)};
674  Real hi_areaHi_z {hi_eb_cc.areaHi(2)};
675  RealVect lo_centHi_z {lo_eb_cc.centHi(2)};
676  RealVect hi_centHi_z {hi_eb_cc.centHi(2)};
677  if (idim == 0) {
678  aux_fcent_z(i,j,k+1,0) = (aux_afrac_z(i,j,k+1) > 0.0) // x (mapped)
679  ? ( lo_areaHi_z * (lo_centHi_z[0] - 0.5)
680  + hi_areaHi_z * (hi_centHi_z[0] + 0.5) ) / aux_afrac_z(i,j,k+1)
681  : 0.0;
682  aux_fcent_z(i,j,k+1,1) = (aux_afrac_z(i,j,k+1) > 0.0) // y
683  ? ( lo_areaHi_z * lo_centHi_z[1]
684  + hi_areaHi_z * hi_centHi_z[1] ) / aux_afrac_z(i,j,k+1)
685  : 0.0;
686  } else if (idim == 1) {
687  aux_fcent_z(i,j,k+1,0) = (aux_afrac_z(i,j,k+1) > 0.0) // x
688  ? ( lo_areaHi_z * lo_centHi_z[0]
689  + hi_areaHi_z * hi_centHi_z[0] ) / aux_afrac_z(i,j,k+1)
690  : 0.0;
691  aux_fcent_z(i,j,k+1,1) = (aux_afrac_z(i,j,k+1) > 0.0) // y (mapped)
692  ? ( lo_areaHi_z * (lo_centHi_z[1] - 0.5)
693  + hi_areaHi_z * (hi_centHi_z[1] + 0.5) ) / aux_afrac_z(i,j,k+1)
694  : 0.0;
695  } else if (idim == 2) {
696  aux_fcent_z(i,j,k+1,0) = lo_centHi_z[0]; // x
697  aux_fcent_z(i,j,k+1,1) = lo_centHi_z[1]; // y
698  }
699  }
700 
701  // 5. Boundary Area
702 
703  Real lo_areaBoun {lo_eb_cc.areaBoun()};
704  Real hi_areaBoun {hi_eb_cc.areaBoun()};
705 
706  aux_barea(i,j,k) = lo_areaBoun + hi_areaBoun;
707 
708  // 6. Boundary Centroid
709 
710  RealVect lo_centBoun {lo_eb_cc.centBoun()};
711  RealVect hi_centBoun {hi_eb_cc.centBoun()};
712 
713  if (idim == 0) {
714  aux_bcent(i,j,k,0) = ( lo_areaBoun * (lo_centBoun[0]-0.5) + hi_areaBoun * (hi_centBoun[0]+0.5) ) / aux_barea(i,j,k); // x (mapped)
715  aux_bcent(i,j,k,1) = ( lo_areaBoun * lo_centBoun[1] + hi_areaBoun * hi_centBoun[1] ) / aux_barea(i,j,k); // y
716  aux_bcent(i,j,k,2) = ( lo_areaBoun * lo_centBoun[2] + hi_areaBoun * hi_centBoun[2] ) / aux_barea(i,j,k); // z
717  } else if (idim == 1) {
718  aux_bcent(i,j,k,0) = ( lo_areaBoun * lo_centBoun[0] + hi_areaBoun * hi_centBoun[0] ) / aux_barea(i,j,k); // x
719  aux_bcent(i,j,k,1) = ( lo_areaBoun * (lo_centBoun[1]-0.5) + hi_areaBoun * (hi_centBoun[1]+0.5) ) / aux_barea(i,j,k); // y (mapped)
720  aux_bcent(i,j,k,2) = ( lo_areaBoun * lo_centBoun[2] + hi_areaBoun * hi_centBoun[2] ) / aux_barea(i,j,k); // z
721  } else if (idim == 2) {
722  aux_bcent(i,j,k,0) = ( lo_areaBoun * lo_centBoun[0] + hi_areaBoun * hi_centBoun[0] ) / aux_barea(i,j,k); // x
723  aux_bcent(i,j,k,1) = ( lo_areaBoun * lo_centBoun[1] + hi_areaBoun * hi_centBoun[1] ) / aux_barea(i,j,k); // y
724  aux_bcent(i,j,k,2) = ( lo_areaBoun * (lo_centBoun[2]-0.5) + hi_areaBoun * (hi_centBoun[2]+0.5) ) / aux_barea(i,j,k); // z (mapped)
725  }
726 
727  // 7. Boundary Normal
728 
729  RealVect eb_normal = ( lo_areaBoun * lo_normal + hi_areaBoun * hi_normal )/ aux_barea(i,j,k);
730 
731  aux_bnorm(i,j,k,0) = eb_normal[0];
732  aux_bnorm(i,j,k,1) = eb_normal[1];
733  aux_bnorm(i,j,k,2) = eb_normal[2];
734  }
735 
736  } // flag(iv_lo) and flag(iv_hi)
737  });
738 
739 
740  // Set Connectivities
741 
742  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
743  {
744  EB2::build_cellflag_from_ap (i, j, k, aux_flag, aux_afrac_x, aux_afrac_y, aux_afrac_z);
745  });
746 
747  } // if (FlagFab[mfi].getType(bx) == FabType::singlevalued )
748 
749  } // MFIter
750 
751  // Fill Boundary
752 
753  m_volfrac->FillBoundary(a_geom.periodicity());
754  m_volcent->FillBoundary(a_geom.periodicity());
755  for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
756  m_areafrac[idim]->FillBoundary(a_geom.periodicity());
757  m_facecent[idim]->FillBoundary(a_geom.periodicity());
758  }
759  m_bndryarea->FillBoundary(a_geom.periodicity());
760  m_bndrycent->FillBoundary(a_geom.periodicity());
761  m_bndrynorm->FillBoundary(a_geom.periodicity());
762 
763 }
eb_aux_::m_cellflags
amrex::FabArray< amrex::EBCellFlagFab > * m_cellflags
Definition: ERF_EBAux.H:43
eb_aux_::m_bndrynorm
amrex::MultiFab * m_bndrynorm
Definition: ERF_EBAux.H:48
eb_aux_::m_bndryarea
amrex::MultiFab * m_bndryarea
Definition: ERF_EBAux.H:46
eb_aux_::m_volfrac
amrex::MultiFab * m_volfrac
Definition: ERF_EBAux.H:44
eb_aux_::m_bndrycent
amrex::MultiFab * m_bndrycent
Definition: ERF_EBAux.H:47
eb_aux_::m_facecent
amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > m_facecent
Definition: ERF_EBAux.H:51
eb_aux_::m_volcent
amrex::MultiFab * m_volcent
Definition: ERF_EBAux.H:45
eb_aux_::m_areafrac
amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > m_areafrac
Definition: ERF_EBAux.H:50
eb_cut_cell_
Definition: ERF_EBCutCell.H:14
module_model_constants::epsilon
real(c_double), parameter epsilon
Definition: ERF_module_model_constants.F90:12

Referenced by eb_::make_factory().

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

◆ getAreaFrac()

Array< const MultiFab *, AMREX_SPACEDIM > eb_aux_::getAreaFrac ( ) const
809 {
810  AMREX_ASSERT(m_areafrac[0] != nullptr);
811  return {AMREX_D_DECL(m_areafrac[0], m_areafrac[1], m_areafrac[2])};
812 }

Referenced by redistribute_term().

Here is the caller graph for this function:

◆ getBndryArea()

const MultiFab & eb_aux_::getBndryArea ( ) const
788 {
789  AMREX_ASSERT(m_bndryarea != nullptr);
790  return *m_bndryarea;
791 }

◆ getBndryCent()

const MultiFab & eb_aux_::getBndryCent ( ) const
795 {
796  AMREX_ASSERT(m_bndrycent != nullptr);
797  return *m_bndrycent;
798 }

◆ getBndryNorm()

const MultiFab & eb_aux_::getBndryNorm ( ) const
802 {
803  AMREX_ASSERT(m_bndrynorm != nullptr);
804  return *m_bndrynorm;
805 }

◆ getCentroid()

const MultiFab & eb_aux_::getCentroid ( ) const
781 {
782  AMREX_ASSERT(m_volcent != nullptr);
783  return *m_volcent;
784 }

Referenced by redistribute_term().

Here is the caller graph for this function:

◆ getFaceCent()

Array< const MultiFab *, AMREX_SPACEDIM > eb_aux_::getFaceCent ( ) const
816 {
817  AMREX_ASSERT(m_facecent[0] != nullptr);
818  return {AMREX_D_DECL(m_facecent[0], m_facecent[1], m_facecent[2])};
819 }

Referenced by redistribute_term().

Here is the caller graph for this function:

◆ getMultiEBCellFlagFab()

const FabArray< EBCellFlagFab > & eb_aux_::getMultiEBCellFlagFab ( ) const
767 {
768  AMREX_ASSERT(m_cellflags != nullptr);
769  return *m_cellflags;
770 }

Referenced by redistribute_term().

Here is the caller graph for this function:

◆ getVolFrac()

const MultiFab & eb_aux_::getVolFrac ( ) const
774 {
775  AMREX_ASSERT(m_volfrac != nullptr);
776  return *m_volfrac;
777 }

Referenced by redistribute_term().

Here is the caller graph for this function:

◆ set_verbose()

void eb_aux_::set_verbose ( )
inline
25 { m_verbose = 1; }

Member Data Documentation

◆ m_areafrac

amrex::Array<amrex::MultiFab*,AMREX_SPACEDIM> eb_aux_::m_areafrac {{AMREX_D_DECL(nullptr, nullptr, nullptr)}}
private

Referenced by define(), and getAreaFrac().

◆ m_bndryarea

amrex::MultiFab* eb_aux_::m_bndryarea = nullptr
private

Referenced by define(), and getBndryArea().

◆ m_bndrycent

amrex::MultiFab* eb_aux_::m_bndrycent = nullptr
private

Referenced by define(), and getBndryCent().

◆ m_bndrynorm

amrex::MultiFab* eb_aux_::m_bndrynorm = nullptr
private

Referenced by define(), and getBndryNorm().

◆ m_cellflags

amrex::FabArray<amrex::EBCellFlagFab>* eb_aux_::m_cellflags = nullptr
private

Referenced by define(), and getMultiEBCellFlagFab().

◆ m_facecent

amrex::Array<amrex::MultiFab*,AMREX_SPACEDIM> eb_aux_::m_facecent {{AMREX_D_DECL(nullptr, nullptr, nullptr)}}
private

Referenced by define(), and getFaceCent().

◆ m_verbose

int eb_aux_::m_verbose
private

Referenced by define(), and set_verbose().

◆ m_volcent

amrex::MultiFab* eb_aux_::m_volcent = nullptr
private

Referenced by define(), and getCentroid().

◆ m_volfrac

amrex::MultiFab* eb_aux_::m_volfrac = nullptr
private

Referenced by define(), and getVolFrac().

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