if_bld Namespace Reference

Classes
struct	HorizFace
struct	VertFace
struct	HorizMasks
struct	VertMasks

Functions
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	snapped (amrex::Real b, bool snap) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	raw_face_blank (const amrex::Array4< const amrex::Real > &t, const amrex::Array4< const amrex::Real > &tf, int i, int j, int k, int io, int jo, int ko) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	face_blank (const amrex::Array4< const amrex::Real > &t, const amrex::Array4< const amrex::Real > &tf, int i, int j, int k, int io, int jo, int ko, bool snap, amrex::Real small) noexcept
template<int dir>
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizFace	horiz_face (const amrex::Array4< const amrex::Real > &t, const amrex::Array4< const amrex::Real > &tf, int i, int j, int k, int klo, bool snap, amrex::Real small) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertFace	vert_face (const amrex::Array4< const amrex::Real > &t, const amrex::Array4< const amrex::Real > &tf, int i, int j, int k, bool snap, amrex::Real small) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizMasks	horiz_masks (amrex::Real t, amrex::Real below, amrex::Real above, amrex::Real lo, amrex::Real hi, bool normal_face, bool use_most, bool snap) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizMasks	horiz_masks (const HorizFace &f, bool use_most, bool snap) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertMasks	vert_masks (amrex::Real t, amrex::Real above, amrex::Real south, amrex::Real north, amrex::Real west, amrex::Real east, bool above_floor, bool normal_face, bool use_most, bool snap) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertMasks	vert_masks (const VertFace &f, bool above_floor, bool use_most, bool snap) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	implicit_weight (amrex::Real linear, amrex::Real raw) noexcept

Function Documentation

face_blank()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real if_bld::face_blank ( const amrex::Array4< const amrex::Real > &  t, const amrex::Array4< const amrex::Real > &  tf, int  i, int  j, int  k, int  io, int  jo, int  ko, bool  snap, amrex::Real  small  )

noexcept

The face blanking as the building kernels read it: with the snap, from the snapped cells (solid when either is), so both EB builds give the same staircase; otherwise raw_face_blank; then thresholded at small (eb2.small_volfrac), below which the face counts as fluid.

{
    const amrex::Real b = snap ? amrex::max(snapped(t(i,j,k), snap), snapped(t(i-io,j-jo,k-ko), snap))
                               : raw_face_blank(t, tf, i, j, k, io, jo, ko);
    return (b < small) ? amrex::Real(zero) : b;
}

Referenced by horiz_face(), ERF::make_if_projection_sigma(), and vert_face().

Here is the call graph for this function:

Here is the caller graph for this function:

horiz_face()

template<int dir>

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizFace if_bld::horiz_face ( const amrex::Array4< const amrex::Real > &  t, const amrex::Array4< const amrex::Real > &  tf, int  i, int  j, int  k, int  klo, bool  snap, amrex::Real  small  )

noexcept

Parameters

t	Cell blanking (with at least one ghost cell in each direction)
tf	Face-centred blanking of this direction, or an empty Array4
klo	Lowest cell index of the domain (the face below the domain bottom counts as fluid)
snap	erf.if_snap_partial_cells
small	eb2.small_volfrac

{
    static_assert(dir == 0 || dir == 1, "horiz_face: x- or y-faces only");
    constexpr int io = (dir == 0) ? 1 : 0;
    constexpr int jo = (dir == 1) ? 1 : 0;
    HorizFace f;
    f.t      = face_blank(t, tf, i, j, k, io, jo, 0, snap, small);
    f.below  = (k == klo) ? amrex::Real(zero) : face_blank(t, tf, i, j, k-1, io, jo, 0, snap, small);
    f.above  = face_blank(t, tf, i, j, k+1, io, jo, 0, snap, small);
    f.lo     = (dir == 0) ? face_blank(t, tf, i, j-1, k, io, jo, 0, snap, small)
                          : face_blank(t, tf, i-1, j, k, io, jo, 0, snap, small);
    f.hi     = (dir == 0) ? face_blank(t, tf, i, j+1, k, io, jo, 0, snap, small)
                          : face_blank(t, tf, i+1, j, k, io, jo, 0, snap, small);
    f.raw    = raw_face_blank(t, tf, i, j, k, io, jo, 0);
    f.normal = snap && (snapped(t(i,j,k), snap) != snapped(t(i-io,j-jo,k), snap));
    return f;
}

Here is the call graph for this function:

horiz_masks() [1/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizMasks if_bld::horiz_masks ( amrex::Real  t, amrex::Real  below, amrex::Real  above, amrex::Real  lo, amrex::Real  hi, bool  normal_face, bool  use_most, bool  snap  )

noexcept

Parameters

t	Blanking of the face
below	Blanking of the face below (zero at the domain bottom)
above	Blanking of the face above
lo	Blanking of the neighbouring face on the low side across the other direction
hi	Blanking of the neighbouring face on the high side across the other direction
normal_face	With the snap, a face joining a solid and a fluid cell (wall-normal)
use_most	erf.if_use_most
snap	erf.if_snap_partial_cells

{
    HorizMasks m{};
    // With the snap every solid face has t = 1: a roof face lies in the top solid row
    // (t <= below, the face above fluid), and a face carrying a wall law is not also an
    // interior face. A wall-normal face gets the interior drag (no penetration), not a wall law.
    m.roof = (!normal_face && t > zero && (snap ? t <= below : t < below) && above == zero && use_most) ? one : zero;
    m.lo   = (!normal_face && t > zero && t <= hi && lo == zero && use_most) ? one : zero;
    m.hi   = (!normal_face && t > zero && t <= lo && hi == zero && use_most) ? one : zero;
    m.wall = (t > zero && t < one && !use_most) ? one : zero;                       // all walls without MOST
    m.side = (t > zero && t < one && use_most && m.most() == zero) ? one : zero;    // partial faces not under MOST
    m.interior = (t == one && !(snap && m.most() > zero)) ? one : zero;
    return m;
}

Referenced by horiz_masks(), ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), and ERF::make_if_projection_sigma().

Here is the caller graph for this function:

horiz_masks() [2/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE HorizMasks if_bld::horiz_masks ( const HorizFace &  f, bool  use_most, bool  snap  )

noexcept

{
    return horiz_masks(f.t, f.below, f.above, f.lo, f.hi, f.normal, use_most, snap);
}

Here is the call graph for this function:

implicit_weight()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real if_bld::implicit_weight ( amrex::Real  linear, amrex::Real  raw  )

noexcept

Weight of the drag the implicit projection applies on a face (erf.if_implicit_projection): the linear-drag weight of the kernel, and the full rate on every face the explicit path zeroes after the projection (raw blanking 1, which the kernels leave without a wall law). The latter also caps the vertical roof face of an exact box without the snap, where the explicit kernel adds the roof and the interior drag together (weight 2 t), at one.

{
    return (raw == one) ? amrex::Real(one) : linear;
}

Referenced by ERF::make_if_projection_sigma().

Here is the caller graph for this function:

raw_face_blank()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real if_bld::raw_face_blank ( const amrex::Array4< const amrex::Real > &  t, const amrex::Array4< const amrex::Real > &  tf, int  i, int  j, int  k, int  io, int  jo, int  ko  )

noexcept

The face blanking the explicit path zeroes on after the projection (ERF_SlowRhsPost.cpp): the face-centred fraction when the build has it, else the mean of the two cells the face joins. (io, jo, ko) is the unit vector of the face's direction.

{
    return (tf) ? tf(i,j,k) : myhalf * (t(i,j,k) + t(i-io,j-jo,k-ko));
}

Referenced by face_blank(), horiz_face(), and vert_face().

Here is the caller graph for this function:

snapped()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real if_bld::snapped ( amrex::Real  b, bool  snap  )

noexcept

Cell blanking snapped to solid (1) or fluid (0) at half (erf.if_snap_partial_cells), else as is

{
    return snap ? ((b >= myhalf) ? amrex::Real(one) : amrex::Real(zero)) : b;
}

Referenced by face_blank(), horiz_face(), and vert_face().

Here is the caller graph for this function:

vert_face()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertFace if_bld::vert_face ( const amrex::Array4< const amrex::Real > &  t, const amrex::Array4< const amrex::Real > &  tf, int  i, int  j, int  k, bool  snap, amrex::Real  small  )

noexcept

{
    VertFace f;
    f.t      = face_blank(t, tf, i, j, k,   0, 0, 1, snap, small);
    f.above  = face_blank(t, tf, i, j, k+1, 0, 0, 1, snap, small);
    f.south  = face_blank(t, tf, i, j-1, k, 0, 0, 1, snap, small);
    f.north  = face_blank(t, tf, i, j+1, k, 0, 0, 1, snap, small);
    f.west   = face_blank(t, tf, i-1, j, k, 0, 0, 1, snap, small);
    f.east   = face_blank(t, tf, i+1, j, k, 0, 0, 1, snap, small);
    f.raw    = raw_face_blank(t, tf, i, j, k, 0, 0, 1);
    f.normal = snap && (snapped(t(i,j,k), snap) != snapped(t(i,j,k-1), snap));
    return f;
}

Referenced by ImmersedForcingBuildings_Zmom(), and ERF::make_if_projection_sigma().

Here is the call graph for this function:

Here is the caller graph for this function:

vert_masks() [1/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertMasks if_bld::vert_masks ( amrex::Real  t, amrex::Real  above, amrex::Real  south, amrex::Real  north, amrex::Real  west, amrex::Real  east, bool  above_floor, bool  normal_face, bool  use_most, bool  snap  )

noexcept

Parameters

t	Blanking of the face
above	Blanking of the face above
south,north,west,east	Blanking of the neighbouring z-faces
above_floor	The face is not the domain bottom (k >= 1)
normal_face	With the snap, a face joining a solid and a fluid cell (wall-normal)
use_most	erf.if_use_most
snap	erf.if_snap_partial_cells

{
    VertMasks m{};
    m.south = (!normal_face && t > zero && t <= north && south == zero && use_most && above_floor) ? one : zero;
    m.north = (!normal_face && t > zero && t <= south && north == zero && use_most && above_floor) ? one : zero;
    m.west  = (!normal_face && t > zero && t <= east  && west  == zero && use_most && above_floor) ? one : zero;
    m.east  = (!normal_face && t > zero && t <= west  && east  == zero && use_most && above_floor) ? one : zero;
    m.wall  = (t > zero && t < one && !use_most) ? one : zero;
    m.roof  = (!normal_face && t > zero && above == zero && use_most) ? one : zero;
    // with the snap a face carrying a wall law or the roof drag is not also an interior face
    m.interior = (t == one && !(snap && (m.most() + m.roof) > zero)) ? one : zero;
    return m;
}

Referenced by ImmersedForcingBuildings_Zmom(), ERF::make_if_projection_sigma(), and vert_masks().

Here is the caller graph for this function:

vert_masks() [2/2]

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE VertMasks if_bld::vert_masks ( const VertFace &  f, bool  above_floor, bool  use_most, bool  snap  )

noexcept

{
    return vert_masks(f.t, f.above, f.south, f.north, f.west, f.east, above_floor, f.normal, use_most, snap);
}

Here is the call graph for this function: