ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Functions
ERF_EBRedistribute.cpp File Reference
#include <AMReX_Config.H>
#include <AMReX_Geometry.H>
#include <ERF.H>
#include <ERF_EB.H>
#include <ERF_EBRedistribute.H>
#include "AMReX_EB_Redistribution.H"
Include dependency graph for ERF_EBRedistribute.cpp:

Functions

void redistribute_term (int ncomp, const Geometry &geom, MultiFab &result, MultiFab &result_tmp, MultiFab const &state, EBFArrayBoxFactory const &ebfact, BCRec const *bc, double local_dt_d)
 
void redistribute_term (int ncomp, const Geometry &geom, MultiFab &result, MultiFab &result_tmp, MultiFab const &state, eb_aux_ const &ebfact, BCRec const *bc, double local_dt_d, int const igrid)
 

Function Documentation

◆ redistribute_term() [1/2]

void redistribute_term ( int  ncomp,
const Geometry &  geom,
MultiFab &  result,
MultiFab &  result_tmp,
MultiFab const &  state,
eb_aux_ const &  ebfact,
BCRec const *  bc,
double  local_dt_d,
int const  igrid 
)
98 {
99  BL_PROFILE_VAR("redistribute_term2", redistribute_term2);
100  // ************************************************************************
101  // Redistribute result_tmp and pass out result
102  // ************************************************************************
103  AMREX_ASSERT(result.nComp() == state.nComp());
104 
105  Real local_dt = static_cast<Real>(local_dt_d);
106 
107  result_tmp.FillBoundary(geom.periodicity());
108 
109 #ifdef _OPENMP
110 #pragma omp parallel if (Gpu::notInLaunchRegion())
111 #endif
112  for (MFIter mfi(state,TilingIfNotGPU()); mfi.isValid(); ++mfi)
113  {
114  Box const& bx = mfi.tilebox();
115 
116  EBCellFlagFab const& flagfab = ebfact.getMultiEBCellFlagFab()[mfi];
117  Array4<EBCellFlag const> const& flag = flagfab.const_array();
118 
119  bool regular = (flagfab.getType(amrex::grow(bx,4)) == FabType::regular);
120  bool covered = (flagfab.getType(bx) == FabType::covered);
121 
122  Array4<Real> out = result.array(mfi);
123  Array4<Real> in = result_tmp.array(mfi);
124 
125  if (!regular && !covered)
126  {
127  auto const& vfrac = ebfact.getVolFrac().const_array(mfi);
128  auto const& ccc = ebfact.getCentroid().const_array(mfi);
129 
130  auto const& apx = ebfact.getAreaFrac()[0]->const_array(mfi);
131  auto const& apy = ebfact.getAreaFrac()[1]->const_array(mfi);
132  auto const& apz = ebfact.getAreaFrac()[2]->const_array(mfi);
133 
134  auto const& fcx = ebfact.getFaceCent()[0]->const_array(mfi);
135  auto const& fcy = ebfact.getFaceCent()[1]->const_array(mfi);
136  auto const& fcz = ebfact.getFaceCent()[2]->const_array(mfi);
137 
138  Box bx_cc = bx;
139  bx_cc = bx_cc.convert(IntVect::TheZeroVector());
140 
141  // Extend box for staggered grids
142  if (igrid == IntVars::xmom) bx_cc = bx_cc.setBig(0, bx_cc.bigEnd(0) + 1);
143  if (igrid == IntVars::ymom) bx_cc = bx_cc.setBig(1, bx_cc.bigEnd(1) + 1);
144  if (igrid == IntVars::zmom) bx_cc = bx_cc.setBig(2, bx_cc.bigEnd(2) + 1);
145 
146  Box gbx = bx_cc; gbx.grow(3);
147 
148  // Extended geometry domain
149  Box domain_grown = geom.Domain();
150  domain_grown.grow(igrid-1, 1); // Extend geometry domain by 1 in the staggering direction
151  Geometry geom_new(domain_grown, geom.ProbDomain(), geom.Coord(), geom.isPeriodic());
152 
153  FArrayBox scratch_fab(gbx,ncomp);
154  Array4<Real> scratch = scratch_fab.array();
155  Elixir eli_scratch = scratch_fab.elixir();
156 
157  // This is scratch space if calling StateRedistribute
158 
159  std::string redistribution_type = "StateRedist";
160 
161  // State redist acts on the state.
162  Array4<Real const> state_arr = state.const_array(mfi);
163  ApplyRedistribution( bx_cc, ncomp, out, in, state_arr,
164  scratch, flag,
165  apx, apy, apz, vfrac,
166  fcx, fcy, fcz, ccc,
167  bc, geom_new, local_dt, redistribution_type,
168  false, 2, 0.5_rt, {});
169  }
170  else
171  {
172  ParallelFor(bx, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) noexcept
173  {
174  out(i,j,k,n) = in(i,j,k,n);
175  });
176  }
177  } // MFIter
178 }
out
struct @29 out
in
struct @29 in
ParallelFor
ParallelFor(grown_box, [=] AMREX_GPU_DEVICE(int i, int j, int k) { qrcuten_arr(i, j, k)=Real(0);qscuten_arr(i, j, k)=Real(0);qicuten_arr(i, j, k)=Real(0);})
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
IntVars::ymom
@ ymom
Definition: ERF_IndexDefines.H:195
IntVars::zmom
@ zmom
Definition: ERF_IndexDefines.H:196
IntVars::xmom
@ xmom
Definition: ERF_IndexDefines.H:194
module_mp_morr_two_moment::bc
real(c_double), private bc
Definition: ERF_module_mp_morr_two_moment.F90:182
Here is the call graph for this function:

◆ redistribute_term() [2/2]

void redistribute_term ( int  ncomp,
const Geometry &  geom,
MultiFab &  result,
MultiFab &  result_tmp,
MultiFab const &  state,
EBFArrayBoxFactory const &  ebfact,
BCRec const *  bc,
double  local_dt_d 
)
21 {
22  BL_PROFILE_VAR("redistribute_term1", redistribute_term1);
23  // ************************************************************************
24  // Redistribute result_tmp and pass out result
25  // ************************************************************************
26  AMREX_ASSERT(result.nComp() == state.nComp());
27 
28  Real local_dt = static_cast<Real>(local_dt_d);
29 
30  result_tmp.FillBoundary(geom.periodicity());
31 
32 #ifdef _OPENMP
33 #pragma omp parallel if (Gpu::notInLaunchRegion())
34 #endif
35  for (MFIter mfi(state,TilingIfNotGPU()); mfi.isValid(); ++mfi)
36  {
37  Box const& bx = mfi.tilebox();
38 
39  EBCellFlagFab const& flagfab = ebfact.getMultiEBCellFlagFab()[mfi];
40  Array4<EBCellFlag const> const& flag = flagfab.const_array();
41 
42  bool regular = (flagfab.getType(amrex::grow(bx,4)) == FabType::regular);
43  bool covered = (flagfab.getType(bx) == FabType::covered);
44 
45  Array4<Real> out = result.array(mfi);
46  Array4<Real> in = result_tmp.array(mfi);
47 
48  if (!regular && !covered)
49  {
50  auto const& vfrac = ebfact.getVolFrac().const_array(mfi);
51  auto const& ccc = ebfact.getCentroid().const_array(mfi);
52 
53  auto const& apx = ebfact.getAreaFrac()[0]->const_array(mfi);
54  auto const& apy = ebfact.getAreaFrac()[1]->const_array(mfi);
55  auto const& apz = ebfact.getAreaFrac()[2]->const_array(mfi);
56 
57  auto const& fcx = ebfact.getFaceCent()[0]->const_array(mfi);
58  auto const& fcy = ebfact.getFaceCent()[1]->const_array(mfi);
59  auto const& fcz = ebfact.getFaceCent()[2]->const_array(mfi);
60 
61  Box gbx = bx; gbx.grow(3);
62 
63  FArrayBox scratch_fab(gbx,ncomp);
64  Array4<Real> scratch = scratch_fab.array();
65  Elixir eli_scratch = scratch_fab.elixir();
66 
67  std::string redistribution_type = "StateRedist";
68 
69  // State redist acts on the state.
70  Array4<Real const> state_arr = state.const_array(mfi);
71  ApplyRedistribution( bx, ncomp, out, in, state_arr,
72  scratch, flag,
73  apx, apy, apz, vfrac,
74  fcx, fcy, fcz, ccc,
75  bc, geom, local_dt, redistribution_type,
76  false, 2, 0.5_rt, {});
77  }
78  else
79  {
80  ParallelFor(bx, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) noexcept
81  {
82  out(i,j,k,n) = in(i,j,k,n);
83  });
84  }
85  } // MFIter
86 }
Here is the call graph for this function: