PoPS/doxygen/operator_8hpp_source.html

#pragma once


#include <pops/core/state/state.hpp>

#include <pops/core/foundation/types.hpp>

#include <pops/mesh/layout/box_array.hpp>

#include <pops/mesh/storage/fab2d.hpp>

#include <pops/mesh/execution/for_each.hpp>

#include <pops/mesh/geometry/geometry.hpp>

#include <pops/mesh/storage/multifab.hpp>

#include <pops/numerics/elliptic/eb/cut_fraction.hpp>  // detail::cut_fraction, CutFraction (PR1)

#include <pops/numerics/fv/numerical_flux.hpp>

#include <pops/numerics/fv/reconstruction.hpp>

#include <pops/numerics/spatial/embedded_boundary/domain.hpp>  // detail::DiscDomain (level-set domain; numerics, not runtime)

#include <pops/numerics/spatial_operator.hpp>  // reconstruct<>, load_state/load_aux, *_face_box (REUSED verbatim)


#include <utility>

#include <vector>


namespace pops {


namespace detail {


constexpr Real kEbFaceOpenEps = Real(1e-6);


constexpr Real kEbKappaMin = Real(1e-2);


struct DiscLevelSet {

  DiscDomain disc;

  POPS_HD Real operator()(Real x, Real y) const { return disc.level_set(x, y); }

};


POPS_HD inline DiscLevelSet disc_level_set(const DiscDomain& d) {

  return DiscLevelSet{d};

}


template <class LevelSet>


POPS_HD inline bool eb_cell_active(const LevelSet& ls, Real xc, Real yc) {

  return ls(xc, yc) < Real(0);

}


POPS_HD inline Real eb_face_aperture(Real lc, Real ln, Real h) {

  if (ln >= Real(0))

    return Real(0);                    // inactive neighbor: closed face (wall, no-penetration)

  return cut_distance(lc, ln, h) / h;  // active neighbor: linear aperture (== elliptic wall)

}


template <class Limiter, class NumericalFlux, class Model, class LevelSet>


struct EbFaceFluxXKernel {

  Model model;

  ConstArray4 u, ax;

  Array4 fx;  // output: alpha_x * Fx at the face between i-1 and i (ncomp components)

  Real dx;

  Geometry geom;  // cell centers (level set evaluated at the center, like cut_fraction)

  LevelSet ls;

  Limiter lim;

  NumericalFlux nflux;

  bool recon_prim;

  Real pos_floor = Real(0);

  int pos_comp = 0;


  POPS_HD void operator()(int i, int j) const {

    const Real xL = geom.x_cell(i - 1), xR = geom.x_cell(i), yc = geom.y_cell(j);

    const Real lL = ls(xL, yc), lR = ls(xR, yc);

    const bool aL = lL < Real(0), aR = lR < Real(0);

    Real alpha;

    if (aL && aR) {

      alpha = eb_face_aperture(lL, lR, dx);  // internal active/active face: symmetric aperture

    } else if (aR) {

      alpha = eb_face_aperture(lR, lL, dx);  // (i) active, (i-1) inactive: closed face (0)

    } else if (aL) {

      alpha = eb_face_aperture(lL, lR, dx);  // (i-1) active, (i) inactive: closed face (0)

    } else {

      alpha = Real(0);  // both inactive: face outside the active domain

    }

    if (alpha < kEbFaceOpenEps) {  // closed face (immersed wall): zero normal flux

      for (int c = 0; c < Model::n_vars; ++c)

        fx(i, j, c) = Real(0);

      return;

    }

    const auto L =

        reconstruct_pp<Model>(model, u, i - 1, j, 0, +1, lim, recon_prim, pos_floor, pos_comp);

    const auto Rr =

        reconstruct_pp<Model>(model, u, i, j, 0, -1, lim, recon_prim, pos_floor, pos_comp);

    const auto F = nflux(model, L, load_aux<aux_comps<Model>()>(ax, i - 1, j), Rr,

                         load_aux<aux_comps<Model>()>(ax, i, j), 0);

    for (int c = 0; c < Model::n_vars; ++c)

      fx(i, j, c) = alpha * F[c];

  }


};


template <class Limiter, class NumericalFlux, class Model, class LevelSet>


struct EbFaceFluxYKernel {

  Model model;

  ConstArray4 u, ax;

  Array4 fy;

  Real dy;

  Geometry geom;

  LevelSet ls;

  Limiter lim;

  NumericalFlux nflux;

  bool recon_prim;

  Real pos_floor = Real(0);

  int pos_comp = 0;


  POPS_HD void operator()(int i, int j) const {

    const Real xc = geom.x_cell(i), yL = geom.y_cell(j - 1), yR = geom.y_cell(j);

    const Real lL = ls(xc, yL), lR = ls(xc, yR);

    const bool aL = lL < Real(0), aR = lR < Real(0);

    Real alpha;

    if (aL && aR) {

      alpha = eb_face_aperture(lL, lR, dy);

    } else if (aR) {

      alpha = eb_face_aperture(lR, lL, dy);

    } else if (aL) {

      alpha = eb_face_aperture(lL, lR, dy);

    } else {

      alpha = Real(0);

    }

    if (alpha < kEbFaceOpenEps) {

      for (int c = 0; c < Model::n_vars; ++c)

        fy(i, j, c) = Real(0);

      return;

    }

    const auto L =

        reconstruct_pp<Model>(model, u, i, j - 1, 1, +1, lim, recon_prim, pos_floor, pos_comp);

    const auto Rr =

        reconstruct_pp<Model>(model, u, i, j, 1, -1, lim, recon_prim, pos_floor, pos_comp);

    const auto F = nflux(model, L, load_aux<aux_comps<Model>()>(ax, i, j - 1), Rr,

                         load_aux<aux_comps<Model>()>(ax, i, j), 1);

    for (int c = 0; c < Model::n_vars; ++c)

      fy(i, j, c) = alpha * F[c];

  }


};


template <class Model, class LevelSet>


struct EbAssembleRhsKernel {

  Model model;

  ConstArray4 u, ax, fx, fy;  // state, aux, x flux weighted by alpha, y flux weighted by alpha

  Array4 r;                   // output: residual

  Real dx, dy;

  Geometry geom;

  LevelSet ls;

  Real kappa_min;


  POPS_HD void operator()(int i, int j) const {

    const Real xc = geom.x_cell(i), yc = geom.y_cell(j);

    if (!eb_cell_active(ls, xc, yc)) {  // outside the disc: zero residual, not advanced (cf. T2)

      for (int c = 0; c < Model::n_vars; ++c)

        r(i, j, c) = Real(0);

      return;

    }

    // Volume fraction kappa derived EXACTLY from the same cut_fraction as the elliptic wall: the

    // cut geometry is the single source of truth (face apertures AND volume). kappa in (0, 1].

    const CutFraction cf = cut_fraction(ls, xc, yc, dx, dy);

    // SMALL-CELL CLAMP: bounds 1/kappa to 1/kappa_min -> finite residual, stable fixed step. Acts ONLY on

    // the denominator (volume); the fluxes (numerator) are unchanged -> GLOBAL conservation preserved.

    const Real kappa_eff = cf.kappa > kappa_min ? cf.kappa : kappa_min;

    const Real inv_kappa = Real(1) / kappa_eff;


    const Aux Ac = load_aux<aux_comps<Model>()>(ax, i, j);

    const auto S = model.source(load_state<Model>(u, i, j), Ac);


    // Immersed WALL flux (no-penetration): F_wall = 0 -> zero term. Single attachment point for a

    // future nonzero wall flux. Stays at 0 in PR2 (solid wall, like the elliptic Dirichlet wall).

    constexpr Real wall_flux = Real(0);


    for (int c = 0; c < Model::n_vars; ++c) {

      const Real div_x = (fx(i + 1, j, c) - fx(i, j, c)) / dx;  // discrete d_x(alpha Fx)

      const Real div_y = (fy(i, j + 1, c) - fy(i, j, c)) / dy;  // discrete d_y(alpha Fy)

      // TERM-BY-TERM accumulation (and not inv_kappa*(div_x + div_y)): when kappa_eff = 1 and all

      // alpha = 1 (case WITHOUT cut), inv_kappa = 1 and each inv_kappa*div_* = div_* by IEEE identity

      // (x*1.0 == x), so r = S - div_x - div_y - 0 reproduces BIT FOR BIT the Cartesian operator

      // (S - (Fxp-Fxm)/dx - (Fyp-Fym)/dy), term by term. A grouping (div_x + div_y) would break

      // floating-point associativity and the bit-identity of the default path.

      r(i, j, c) = S[c] - inv_kappa * div_x - inv_kappa * div_y - inv_kappa * wall_flux;

    }

  }


};


}  // namespace detail


template <class Limiter = NoSlope, class NumericalFlux = RusanovFlux, class Model, class LevelSet>


void assemble_rhs_eb(const Model& model, const MultiFab& U, const MultiFab& aux, const LevelSet& ls,

                     const Geometry& geom, MultiFab& R, bool recon_prim = false,

                     Real kappa_min = detail::kEbKappaMin, Real pos_floor = Real(0)) {

  // STATE-GHOST WIDTH: exactly Limiter::n_ghost, like the Cartesian operator. The EB face kernels

  // (EbFaceFluxXKernel / EbFaceFluxYKernel) reuse reconstruct_pp<> VERBATIM at the SAME i-1/i

  // offsets over the SAME face boxes (xface_box/yface_box, up to hi+1) as compute_face_fluxes ->

  // identical reconstruction stencil (i+-Limiter::n_ghost at the edge of the valid box). The EB

  // geometry (level set ls, cut_fraction/cut_distance) is evaluated at cell-center COORDINATES

  // (geom.x_cell/y_cell), never on U, so it adds NO state-ghost width; aux is read at i+-1 only

  // (1 ghost, narrower). HOST-only guard, BEFORE the pass-1/pass-2 loops -- never inside a kernel.

  detail::require_reconstruction_ghosts<Limiter>(U);  // state ghosts >= stencil (otherwise OOB)

  const Real dx = geom.dx(), dy = geom.dy();

  const Limiter lim{};

  const NumericalFlux nflux{};

  const int pos_comp = detail::positivity_comp<Model>(pos_floor);

  // FACE BoxArrays (cf. compute_face_fluxes / polar operator): x faces = surroundingNodes in x

  // (xface_box), y faces in y (yface_box). fx(i, .) is the face between i-1 and i, fy(., j) between j-1 and j.

  std::vector<Box2D> xfaces, yfaces;

  xfaces.reserve(U.box_array().size());

  yfaces.reserve(U.box_array().size());

  for (const Box2D& b : U.box_array().boxes()) {

    xfaces.push_back(xface_box(b));

    yfaces.push_back(yface_box(b));

  }

  MultiFab Fx(BoxArray(std::move(xfaces)), U.dmap(), Model::n_vars, 0);

  MultiFab Fy(BoxArray(std::move(yfaces)), U.dmap(), Model::n_vars, 0);

  // PASS 1: face fluxes weighted by alpha_f.

  for (int li = 0; li < U.local_size(); ++li) {

    const ConstArray4 u = U.fab(li).const_array();

    const ConstArray4 ax = aux.fab(li).const_array();

    Array4 fx = Fx.fab(li).array();

    Array4 fy = Fy.fab(li).array();

    const Box2D v = R.box(li);

    for_each_cell(xface_box(v),

                  detail::EbFaceFluxXKernel<Limiter, NumericalFlux, Model, LevelSet>{

                      model, u, ax, fx, dx, geom, ls, lim, nflux, recon_prim, pos_floor, pos_comp});

    for_each_cell(yface_box(v),

                  detail::EbFaceFluxYKernel<Limiter, NumericalFlux, Model, LevelSet>{

                      model, u, ax, fy, dy, geom, ls, lim, nflux, recon_prim, pos_floor, pos_comp});

  }

  // PASS 2: EB divergence / kappa_eff + source; inactive cell -> residual 0.

  for (int li = 0; li < U.local_size(); ++li) {

    const ConstArray4 u = U.fab(li).const_array();

    const ConstArray4 ax = aux.fab(li).const_array();

    const ConstArray4 fx = Fx.fab(li).const_array();

    const ConstArray4 fy = Fy.fab(li).const_array();

    Array4 r = R.fab(li).array();

    const Box2D v = R.box(li);

    for_each_cell(v, detail::EbAssembleRhsKernel<Model, LevelSet>{model, u, ax, fx, fy, r, dx, dy,

                                                                  geom, ls, kappa_min});

  }

}


}  // namespace pops

box_array.hpp
BoxArray: the set of boxes tiling a level (disjoint, covering).

pops::BoxArray
Ordered list of boxes tiling a level.
Definition box_array.hpp:22

pops::BoxArray::size
int size() const
Number of boxes in the tiling.
Definition box_array.hpp:42

pops::BoxArray::boxes
const std::vector< Box2D > & boxes() const
View on the underlying vector (element-by-element equality = same boxes AND same order).
Definition box_array.hpp:46

pops::Fab2D::const_array
ConstArray4 const_array() const
READ handle (POD device-copyable) over this Fab. Valid as long as the Fab lives.
Definition fab2d.hpp:96

pops::Fab2D::array
Array4 array()
WRITE handle (POD device-copyable) over this Fab. Valid as long as the Fab lives.
Definition fab2d.hpp:91

pops::MultiFab
Field distributed over a level: decomposition (BoxArray) + distribution (DistributionMapping) + ncomp...
Definition multifab.hpp:33

pops::MultiFab::fab
Fab2D & fab(int li)
Local fab at index li (0 <= li < local_size()), for writing.
Definition multifab.hpp:67

pops::MultiFab::dmap
const DistributionMapping & dmap() const
GLOBAL distribution (owner rank per box).
Definition multifab.hpp:58

pops::MultiFab::box_array
const BoxArray & box_array() const
GLOBAL decomposition of the level (all boxes, all ranks).
Definition multifab.hpp:56

pops::MultiFab::box
const Box2D & box(int li) const
VALID box of local fab li.
Definition multifab.hpp:71

pops::MultiFab::local_size
int local_size() const
Number of fabs OWNED by this rank (bound on local indices).
Definition multifab.hpp:65

cut_fraction.hpp
SHARED cut-fraction primitive (cut-cell / embedded boundary).

domain.hpp
Generic EMBEDDED-BOUNDARY / LEVEL-SET DOMAIN contract (ADC-327).

fab2d.hpp
Fab2D: single-grid data on a Box2D (in-house equivalent of AMReX's FArrayBox); Array4 / ConstArray4: ...

for_each.hpp
for_each_cell and reductions: the parallelism SEAM over the cells of a Box2D; sync_host / sync_device...

geometry.hpp
Geometry: index-space (Box2D) <-> Cartesian physical-space mapping; PolarGeometry: SIBLING for a glob...

multifab.hpp
MultiFab: a field DISTRIBUTED over a level (equivalent of AMReX's MultiFab).

pops::detail::disc_level_set
POPS_HD DiscLevelSet disc_level_set(const DiscDomain &d)
Builds the disc level set callable from a DiscDomain (sugar: disc_level_set(d)).
Definition operator.hpp:122

pops::detail::kEbKappaMin
constexpr Real kEbKappaMin
Definition operator.hpp:109

pops::detail::cut_fraction
POPS_HD CutFraction cut_fraction(const LevelSet &ls, Real xc, Real yc, Real dx, Real dy)
Computes the cut geometry of an ACTIVE cell (center (xc, yc) with ls < 0) from a level-set ls evaluat...
Definition cut_fraction.hpp:76

pops::detail::eb_cell_active
POPS_HD bool eb_cell_active(const LevelSet &ls, Real xc, Real yc)
Activity indicator (center in the disc, ls < 0) from a callable level set. POPS_HD.
Definition operator.hpp:128

pops::detail::eb_face_aperture
POPS_HD Real eb_face_aperture(Real lc, Real ln, Real h)
Definition operator.hpp:147

pops::detail::cut_distance
POPS_HD Real cut_distance(Real lc, Real ln, Real h)
Cut distance of ONE face along a direction, starting from the active center (ls < 0).
Definition cut_fraction.hpp:33

pops::detail::kEbFaceOpenEps
constexpr Real kEbFaceOpenEps
Default aperture below which a face is treated as CLOSED (immersed wall).
Definition operator.hpp:104

pops
Definition amr_hierarchy.hpp:29

pops::for_each_cell
void for_each_cell(const Box2D &b, F f)
Applies f to EACH cell (i, j) of box b (bounds inclusive), via Kokkos::parallel_for (Serial / OpenMP ...
Definition for_each.hpp:138

pops::Real
double Real
Definition types.hpp:30

pops::load_aux
POPS_HD Aux load_aux(const ConstArray4 &a, int i, int j)
load_aux<NComp>: reads NComp components of the auxiliary from an Array4 at (i,j).
Definition state_access.hpp:141

pops::assemble_rhs_eb
void assemble_rhs_eb(const Model &model, const MultiFab &U, const MultiFab &aux, const LevelSet &ls, const Geometry &geom, MultiFab &R, bool recon_prim=false, Real kappa_min=detail::kEbKappaMin, Real pos_floor=Real(0))
assemble_rhs_eb<Limiter, NumericalFlux>: residual R = -div_eb F + S on a DISC in cut-cell / EB,...
Definition operator.hpp:324

pops::xface_box
Box2D xface_box(const Box2D &v)
xface_box / yface_box: face boxes normal to x (resp.
Definition face_flux.hpp:147

pops::yface_box
Box2D yface_box(const Box2D &v)
Definition face_flux.hpp:150

numerical_flux.hpp
Single-interface numerical flux policies: Rusanov, HLL, HLLC, Roe.

reconstruction.hpp
Interface reconstruction policies: MUSCL limiters and WENO5-Z.

spatial_operator.hpp
Cartesian spatial operator: assembles R(U, aux) = -div F + S over the cells of a level.

state.hpp
Pointwise types of the physics layer: StateVec<N> (conserved state) and Aux (auxiliary fields from th...

pops::Array4
WRITE POD handle (raw pointer + strides) over a Fab2D buffer, indexed by (i, j, c) IN GLOBAL INDICES ...
Definition fab2d.hpp:29

pops::Aux
POINTWISE auxiliary fields shared with the physics: single coupling channel.
Definition state.hpp:123

pops::Box2D
2D integer index space, cell-centered.
Definition box2d.hpp:37

pops::ConstArray4
READ-only handle (const counterpart of Array4): same layout and same contract (POD device-copyable,...
Definition fab2d.hpp:44

pops::Geometry
Cartesian geometry of a level: index domain + physical bounds [xlo, xhi] x [ylo, yhi].
Definition geometry.hpp:20

pops::Geometry::x_cell
POPS_HD Real x_cell(int i) const
Abscissa at the CENTER of cell index i (i = 0 -> xlo + dx/2; defined for negative i)....
Definition geometry.hpp:35

pops::Geometry::dy
POPS_HD Real dy() const
Grid spacing in y (= (yhi - ylo) / domain.ny()). POPS_HD.
Definition geometry.hpp:33

pops::Geometry::dx
POPS_HD Real dx() const
Grid spacing in x (= (xhi - xlo) / domain.nx()). POPS_HD.
Definition geometry.hpp:31

pops::Geometry::y_cell
POPS_HD Real y_cell(int j) const
Ordinate at the CENTER of cell index j. POPS_HD.
Definition geometry.hpp:37

pops::detail::CutFraction
Geometric result of crossing a cut cell: 4 cut distances per face, the 4 apertures alpha_f normalized...
Definition cut_fraction.hpp:52

pops::detail::CutFraction::kappa
Real kappa
volume fraction of the cell (share in the active domain), in (0, 1]
Definition cut_fraction.hpp:61

pops::detail::DiscDomain
CIRCLE / DISC level-set domain: the canonical instance of the contract and the SINGLE SOURCE of truth...
Definition domain.hpp:69

pops::detail::DiscDomain::level_set
POPS_HD Real level_set(Real x, Real y) const
Level set ls(x, y) = hypot(x - cx, y - cy) - R: < 0 inside, 0 at the boundary, > 0 outside.
Definition domain.hpp:82

pops::detail::DiscLevelSet
Device-safe adapter wrapping a DiscDomain as the Real(Real, Real) callable expected by cut_fraction a...
Definition operator.hpp:116

pops::detail::DiscLevelSet::operator()
POPS_HD Real operator()(Real x, Real y) const
Definition operator.hpp:118

pops::detail::DiscLevelSet::disc
DiscDomain disc
Definition operator.hpp:117

pops::detail::EbAssembleRhsKernel
Kernel assembling the EB residual at cell (i, j): INACTIVE cell -> residual 0 (not advanced,...
Definition operator.hpp:256

pops::detail::EbAssembleRhsKernel::geom
Geometry geom
Definition operator.hpp:261

pops::detail::EbAssembleRhsKernel::operator()
POPS_HD void operator()(int i, int j) const
Definition operator.hpp:264

pops::detail::EbAssembleRhsKernel::model
Model model
Definition operator.hpp:257

pops::detail::EbAssembleRhsKernel::ls
LevelSet ls
Definition operator.hpp:262

pops::detail::EbAssembleRhsKernel::u
ConstArray4 u
Definition operator.hpp:258

pops::detail::EbAssembleRhsKernel::dx
Real dx
Definition operator.hpp:260

pops::detail::EbAssembleRhsKernel::r
Array4 r
Definition operator.hpp:259

pops::detail::EbAssembleRhsKernel::kappa_min
Real kappa_min
Definition operator.hpp:263

pops::detail::EbAssembleRhsKernel::dy
Real dy
Definition operator.hpp:260

pops::detail::EbAssembleRhsKernel::fy
ConstArray4 fy
Definition operator.hpp:258

pops::detail::EbAssembleRhsKernel::ax
ConstArray4 ax
Definition operator.hpp:258

pops::detail::EbAssembleRhsKernel::fx
ConstArray4 fx
Definition operator.hpp:258

pops::detail::EbFaceFluxXKernel
FACE FLUX kernel for x (dir 0) of the EB transport: numerical flux at the face between (i-1,...
Definition operator.hpp:162

pops::detail::EbFaceFluxXKernel::model
Model model
Definition operator.hpp:163

pops::detail::EbFaceFluxXKernel::u
ConstArray4 u
Definition operator.hpp:164

pops::detail::EbFaceFluxXKernel::pos_comp
int pos_comp
component of the Density role (resolved by the host caller)
Definition operator.hpp:173

pops::detail::EbFaceFluxXKernel::recon_prim
bool recon_prim
Definition operator.hpp:171

pops::detail::EbFaceFluxXKernel::ax
ConstArray4 ax
Definition operator.hpp:164

pops::detail::EbFaceFluxXKernel::dx
Real dx
Definition operator.hpp:166

pops::detail::EbFaceFluxXKernel::nflux
NumericalFlux nflux
Definition operator.hpp:170

pops::detail::EbFaceFluxXKernel::pos_floor
Real pos_floor
Zhang-Shu positivity limiter (<= 0: inactive, bit-identical)
Definition operator.hpp:172

pops::detail::EbFaceFluxXKernel::geom
Geometry geom
Definition operator.hpp:167

pops::detail::EbFaceFluxXKernel::operator()
POPS_HD void operator()(int i, int j) const
Definition operator.hpp:174

pops::detail::EbFaceFluxXKernel::lim
Limiter lim
Definition operator.hpp:169

pops::detail::EbFaceFluxXKernel::fx
Array4 fx
Definition operator.hpp:165

pops::detail::EbFaceFluxXKernel::ls
LevelSet ls
Definition operator.hpp:168

pops::detail::EbFaceFluxYKernel
FACE FLUX kernel for y (dir 1) of the EB transport: analogue of EbFaceFluxXKernel in j.
Definition operator.hpp:207

pops::detail::EbFaceFluxYKernel::pos_comp
int pos_comp
component of the Density role (resolved by the host caller)
Definition operator.hpp:218

pops::detail::EbFaceFluxYKernel::nflux
NumericalFlux nflux
Definition operator.hpp:215

pops::detail::EbFaceFluxYKernel::operator()
POPS_HD void operator()(int i, int j) const
Definition operator.hpp:219

pops::detail::EbFaceFluxYKernel::lim
Limiter lim
Definition operator.hpp:214

pops::detail::EbFaceFluxYKernel::pos_floor
Real pos_floor
Zhang-Shu positivity limiter (<= 0: inactive, bit-identical)
Definition operator.hpp:217

pops::detail::EbFaceFluxYKernel::geom
Geometry geom
Definition operator.hpp:212

pops::detail::EbFaceFluxYKernel::ax
ConstArray4 ax
Definition operator.hpp:209

pops::detail::EbFaceFluxYKernel::ls
LevelSet ls
Definition operator.hpp:213

pops::detail::EbFaceFluxYKernel::dy
Real dy
Definition operator.hpp:211

pops::detail::EbFaceFluxYKernel::model
Model model
Definition operator.hpp:208

pops::detail::EbFaceFluxYKernel::u
ConstArray4 u
Definition operator.hpp:209

pops::detail::EbFaceFluxYKernel::recon_prim
bool recon_prim
Definition operator.hpp:216

pops::detail::EbFaceFluxYKernel::fy
Array4 fy
Definition operator.hpp:210

types.hpp
Base scalar types and the POPS_HD macro (host+device portability).

POPS_HD
#define POPS_HD
Definition types.hpp:25