ERF_AdvectionSrcForOpenBC.cpp File Reference

#include <ERF_Advection.H>

Include dependency graph for ERF_AdvectionSrcForOpenBC.cpp:

Functions
void	AdvectionSrcForOpenBC_Normal (const Box &bx, const int &dir, const Array4< Real > &rhs_arr, const Array4< const Real > &vel_norm_arr, const Array4< const Real > &cell_data_arr, const GpuArray< Real, AMREX_SPACEDIM > &dxInv, const bool do_lo)
void	AdvectionSrcForOpenBC_Tangent_Xmom (const Box &bxx, const int &dir, const Array4< Real > &rho_u_rhs, const Array4< const Real > &u, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &Omega, const Array4< const Real > &ax, const Array4< const Real > &az, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const bool do_lo)
void	AdvectionSrcForOpenBC_Tangent_Ymom (const Box &bxy, const int &dir, const Array4< Real > &rho_v_rhs, const Array4< const Real > &v, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &Omega, const Array4< const Real > &ay, const Array4< const Real > &az, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const bool do_lo)
void	AdvectionSrcForOpenBC_Tangent_Zmom (const Box &bxz, const OpenSide x_side, const OpenSide y_side, const Array4< Real > &rho_w_rhs, const Array4< const Real > &w, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &Omega, const Array4< const Real > &ax, const Array4< const Real > &ay, const Array4< const Real > &az, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const int domhi_z)
void	AdvectionSrcForOpenBC_Tangent_Scalars (const Box &bx, const OpenSide x_side, const OpenSide y_side, const int scalar_icomp, const int rhs_icomp, const int ncomp, const Array4< Real > &cell_rhs, const Array4< const Real > &cell_prim, const Array4< const Real > &avg_xmom, const Array4< const Real > &avg_ymom, const Array4< const Real > &avg_zmom, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv)
void	AdvectionSrcForOpenBC_Tangent_Cons (const Box &bx, const OpenSide x_side, const OpenSide y_side, const int &icomp, const int &ncomp, const Array4< Real > &cell_rhs, const Array4< const Real > &cell_prim, const Array4< const Real > &avg_xmom, const Array4< const Real > &avg_ymom, const Array4< const Real > &avg_zmom, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv)
AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE Real	AdvectionSrcForOpenBC_Tangent (const int &i, const int &j, const int &k, const int &nprim, const int &dir, const Array4< const Real > &prim_tang_arr, const Array4< const Real > &mom_norm_arr, const Real &dxInv, const bool do_lo)

Function Documentation

AdvectionSrcForOpenBC_Normal()

void AdvectionSrcForOpenBC_Normal	(	const Box &	bx,
		const int &	dir,
		const Array4< Real > &	rhs_arr,
		const Array4< const Real > &	vel_norm_arr,
		const Array4< const Real > &	cell_data_arr,
		const GpuArray< Real, AMREX_SPACEDIM > &	dxInv,
		const bool	do_lo
	)

Compute advection tendencies for momentum normal to an open boundary.

Parameters

[in]	bx	box over which the boundary-normal momentum is updated
[in]	dir	coordinate direction normal to the open boundary
[out]	rhs_arr	tendency for the boundary-normal momentum equation
[in]	vel_norm_arr	velocity component normal to the open boundary
[in]	cell_data_arr	cell-centered conservative state
[in]	dxInv	inverse grid spacing
[in]	do_lo	flag for a low-side open boundary

{
    // NOTE: Klemp, J. B., and R. Wilhelmson, 1978: The simulation of three-dimensional
    //       convective storm dynamics, J. Atmos. Sci., 35, 1070-Real(1096.)
    // NOTE: Implementation is for the high bndry side. The low bndry side is obtained
    //       by flipping sgn = -one
    // NOTE: Indices (i,j,k) correspond to data that is ON the open bdy.
    int sgn = 1; if (do_lo) sgn = -1;
    Real c_o_star = Real(sgn)*Real(30.0);
    ParallelFor(bx, [=,zero_d=zero] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        IntVect ivu1(i,j,k); if ( do_lo) ivu1[dir] -= sgn; // Vel indexed into domain for do_lo
        IntVect ivu2(i,j,k); if (!do_lo) ivu2[dir] -= sgn; // Vel indexed into domain for do_hi
 
        IntVect ivr1(i,j,k); if (!do_lo) ivr1[dir] -= sgn; // Rho indexed into domain for do_hi
        IntVect ivr2(i,j,k); if ( do_lo) ivr2[dir] += sgn; // Rho indexed out  domain for do_lo
 
        Real rho_face  = myhalf * ( cell_data_arr(ivr1,Rho_comp) + cell_data_arr(ivr2,Rho_comp) );
        Real mom_star  = rho_face * Real(sgn) * max( Real(sgn)*(vel_norm_arr(ivu1) + c_o_star), zero_d );
        Real vel_grad  =  ( vel_norm_arr(ivu1) - vel_norm_arr(ivu2) ) * dxInv[dir];
        Real flux      = -( mom_star * vel_grad );
        rhs_arr(i,j,k) = flux;
    });
}

Here is the call graph for this function:

AdvectionSrcForOpenBC_Tangent()

AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE Real AdvectionSrcForOpenBC_Tangent	(	const int &	i,
		const int &	j,
		const int &	k,
		const int &	nprim,
		const int &	dir,
		const Array4< const Real > &	prim_tang_arr,
		const Array4< const Real > &	mom_norm_arr,
		const Real &	dxInv,
		const bool	do_lo
	)

Compute the open-boundary normal-direction source for a tangential primitive variable.

Parameters

[in]	i	i-index of the target cell
[in]	j	j-index of the target cell
[in]	k	k-index of the target cell
[in]	nprim	primitive component to update
[in]	dir	coordinate direction normal to the open boundary
[in]	prim_tang_arr	primitive variable tangent to the open boundary
[in]	mom_norm_arr	momentum component normal to the open boundary
[in]	dxInv	inverse grid spacing in the open-boundary normal direction
[in]	do_lo	flag for a low-side open boundary

Returns

source contribution before the wrapper applies its sign convention

{
    // NOTE: Klemp, J. B., and R. Wilhelmson, 1978: The simulation of three-dimensional
    //       convective storm dynamics, J. Atmos. Sci., 35, 1070-Real(1096.)
    // NOTE: Implementation is for the high bndry side. The low bndry side is obtained
    //       by flipping sgn = -one
 
    int sgn = 1; if (do_lo) { sgn = -1; }
 
    // NOTE: The indices (i,j,k) passed to this routine correspond to data that resides
    //       1/2 dx away from the open boundary and into the domain. The momentum is
    //       face centered in dir, so it has one more cell than the scalar and cell
    //       (i,j,k) is bounded by the faces (i,j,k) and (i,j,k)+e_dir. One of those two
    //       faces resides on the physical boundary: the high face at a high open bndry,
    //       the low face at a low open bndry. Averaging and differencing that same pair
    //       of faces therefore yields the cell centered momentum and its exact cell
    //       centered gradient on both sides, so no sgn dependence is needed here.
    IntVect ivm1(i,j,k); ivm1[dir] += 1; // Mom on the high face of cell (i,j,k)
    IntVect ivm2(i,j,k);                 // Mom on the low  face of cell (i,j,k)
 
    IntVect ivs1(i,j,k); if ( do_lo) { ivs1[dir] -= sgn; } // Scalar indexed into domain for do_lo
    IntVect ivs2(i,j,k); if (!do_lo) { ivs2[dir] -= sgn; } // Scalar indexed into domain for do_hi
 
    Real mom_at_cc = myhalf * (mom_norm_arr(ivm1) + mom_norm_arr(ivm2));
    Real mom_star  = Real(sgn) * max( Real(sgn)*mom_at_cc, zero );
    Real mom_grad  = ( mom_norm_arr(ivm1) - mom_norm_arr(ivm2) ) * dxInv;
    Real prim_grad = ( prim_tang_arr(ivs1,nprim) - prim_tang_arr(ivs2,nprim) ) * dxInv;
 
    // NOTE: Negative sign taken care of by wrapper function
    Real src       = ( mom_star*prim_grad + prim_tang_arr(i,j,k,nprim)*mom_grad );
    return src;
}

Referenced by AdvectionSrcForOpenBC_Tangent_Scalars(), AdvectionSrcForOpenBC_Tangent_Xmom(), AdvectionSrcForOpenBC_Tangent_Ymom(), and AdvectionSrcForOpenBC_Tangent_Zmom().

Here is the caller graph for this function:

AdvectionSrcForOpenBC_Tangent_Cons()

void AdvectionSrcForOpenBC_Tangent_Cons	(	const Box &	bx,
		const OpenSide	x_side,
		const OpenSide	y_side,
		const int &	icomp,
		const int &	ncomp,
		const Array4< Real > &	cell_rhs,
		const Array4< const Real > &	cell_prim,
		const Array4< const Real > &	avg_xmom,
		const Array4< const Real > &	avg_ymom,
		const Array4< const Real > &	avg_zmom,
		const Array4< const Real > &	detJ,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv
	)

Adapt the native conserved-state layout to the component-explicit scalar open-BC operation.

{
    AMREX_ALWAYS_ASSERT(icomp > 0);
    AdvectionSrcForOpenBC_Tangent_Scalars(bx, x_side, y_side,
                                          icomp - 1, icomp, ncomp,
                                          cell_rhs, cell_prim,
                                          avg_xmom, avg_ymom, avg_zmom,
                                          detJ, cellSizeInv);
}

Here is the call graph for this function:

AdvectionSrcForOpenBC_Tangent_Scalars()

void AdvectionSrcForOpenBC_Tangent_Scalars	(	const Box &	bx,
		const OpenSide	x_side,
		const OpenSide	y_side,
		const int	scalar_icomp,
		const int	rhs_icomp,
		const int	ncomp,
		const Array4< Real > &	cell_rhs,
		const Array4< const Real > &	cell_prim,
		const Array4< const Real > &	avg_xmom,
		const Array4< const Real > &	avg_ymom,
		const Array4< const Real > &	avg_zmom,
		const Array4< const Real > &	detJ,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv
	)

Compute second-order advection tendencies for scalar fields tangent to an open boundary.

Parameters

[in]	bx	box over which the scalar tendencies are updated
[in]	x_side	which x boundary the cells lie on, if any
[in]	y_side	which y boundary the cells lie on, if any
[in]	scalar_icomp	first component of the supplied scalar view to read
[in]	rhs_icomp	first component of the supplied tendency view to write
[in]	ncomp	number of components to update
[out]	cell_rhs	tendency view
[in]	cell_prim	supplied scalar view
[in]	avg_xmom	x-component of time-averaged mass flux
[in]	avg_ymom	y-component of time-averaged mass flux
[in]	avg_zmom	z-component of time-averaged mass flux
[in]	detJ	Jacobian of the metric transformation
[in]	cellSizeInv	inverse grid spacing

{
    // At a corner both sides are set, and neither x nor y may be differenced across
    const bool xopen   = (x_side != OpenSide::none);
    const bool yopen   = (y_side != OpenSide::none);
    const bool x_do_lo = (x_side == OpenSide::lo);
    const bool y_do_lo = (y_side == OpenSide::lo);
 
    AMREX_ALWAYS_ASSERT(xopen || yopen);
 
    auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
 
    ParallelFor(bx, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) noexcept
    {
        if (detJ(i,j,k) > zero) {
            const int scalar_comp = scalar_icomp + n;
            const int rhs_comp = rhs_icomp + n;
            Real prim_xlo = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i-1,j,k,scalar_comp));
            Real prim_xhi = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i+1,j,k,scalar_comp));
            Real xflux_lo = avg_xmom(i  ,j,k) * prim_xlo;
            Real xflux_hi = avg_xmom(i+1,j,k) * prim_xhi;
 
            Real prim_ylo = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i,j-1,k,scalar_comp));
            Real prim_yhi = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i,j+1,k,scalar_comp));
            Real yflux_lo = avg_ymom(i,j  ,k) * prim_ylo;
            Real yflux_hi = avg_ymom(i,j+1,k) * prim_yhi;
 
            Real prim_zlo = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i,j,k-1,scalar_comp));
            Real prim_zhi = myhalf * (cell_prim(i,j,k,scalar_comp) + cell_prim(i,j,k+1,scalar_comp));
            Real zflux_lo = avg_zmom(i,j,k  ) * prim_zlo;
            Real zflux_hi = avg_zmom(i,j,k+1) * prim_zhi;
 
            Real x_src = (xopen) ? AdvectionSrcForOpenBC_Tangent(i, j, k,
                                                                 scalar_comp, 0, cell_prim,
                                                                 avg_xmom, dxInv, x_do_lo) :
                                   (xflux_hi - xflux_lo) * dxInv;
            Real y_src = (yopen) ? AdvectionSrcForOpenBC_Tangent(i, j, k,
                                                                 scalar_comp, 1, cell_prim,
                                                                 avg_ymom, dyInv, y_do_lo) :
                                   (yflux_hi - yflux_lo) * dyInv;
            Real z_src = (zflux_hi - zflux_lo) * dzInv;
            Real advectionSrc = x_src + y_src + z_src;
            cell_rhs(i,j,k,rhs_comp) = -advectionSrc / detJ(i,j,k);
        }
    });
}

Referenced by AdvectionSrcForOpenBC_Tangent_Cons().

Here is the call graph for this function:

Here is the caller graph for this function:

AdvectionSrcForOpenBC_Tangent_Xmom()

void AdvectionSrcForOpenBC_Tangent_Xmom	(	const Box &	bxx,
		const int &	dir,
		const Array4< Real > &	rho_u_rhs,
		const Array4< const Real > &	u,
		const Array4< const Real > &	rho_u,
		const Array4< const Real > &	rho_v,
		const Array4< const Real > &	Omega,
		const Array4< const Real > &	ax,
		const Array4< const Real > &	az,
		const Array4< const Real > &	detJ,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv,
		const bool	do_lo
	)

Compute second-order advection tendencies for x-momentum tangent to an open boundary.

Parameters

[in]	bxx	box over which x-momentum is updated
[in]	dir	coordinate direction normal to the open boundary
[out]	rho_u_rhs	tendency for the x-momentum equation
[in]	u	x-component of velocity
[in]	rho_u	x-component of momentum
[in]	rho_v	y-component of momentum
[in]	Omega	component of momentum normal to the z-coordinate surface
[in]	ax	area fraction of x-faces
[in]	az	area fraction of z-faces
[in]	detJ	Jacobian of the metric transformation
[in]	cellSizeInv	inverse grid spacing
[in]	do_lo	flag for a low-side open boundary

{
    AMREX_ALWAYS_ASSERT(dir==1);
 
    auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
 
    ParallelFor(bxx,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        if (ax(i,j,k) > zero) {
            Real xflux_hi = fourth * (rho_u(i, j  , k) + rho_u(i+1, j  , k)) * (u(i+1,j,k) + u(i,j,k)) * myhalf * (ax(i,j,k) + ax(i+1,j,k));
            Real xflux_lo = fourth * (rho_u(i, j  , k) + rho_u(i-1, j  , k)) * (u(i-1,j,k) + u(i,j,k)) * myhalf * (ax(i,j,k) + ax(i-1,j,k));
 
            Real zflux_hi = fourth * (Omega(i, j, k+1) + Omega(i-1, j, k+1)) * (u(i,j,k+1) + u(i,j,k)) * az(i,j,k+1);
            Real zflux_lo = fourth * (Omega(i, j, k  ) + Omega(i-1, j, k  )) * (u(i,j,k-1) + u(i,j,k)) * az(i,j,k  );
 
            Real x_src = (xflux_hi - xflux_lo) * dxInv;
            Real y_src = AdvectionSrcForOpenBC_Tangent(i, j, k, 0, dir, u, rho_v, dyInv, do_lo);
            Real z_src = (zflux_hi - zflux_lo) * dzInv;
            Real advectionSrc = x_src + y_src + z_src;
 
            rho_u_rhs(i, j, k) = -advectionSrc / (myhalf * (detJ(i,j,k) + detJ(i-1,j,k)));
        } else {
            rho_u_rhs(i, j, k) = zero;
        }
    });
}

Here is the call graph for this function:

AdvectionSrcForOpenBC_Tangent_Ymom()

void AdvectionSrcForOpenBC_Tangent_Ymom	(	const Box &	bxy,
		const int &	dir,
		const Array4< Real > &	rho_v_rhs,
		const Array4< const Real > &	v,
		const Array4< const Real > &	rho_u,
		const Array4< const Real > &	rho_v,
		const Array4< const Real > &	Omega,
		const Array4< const Real > &	ay,
		const Array4< const Real > &	az,
		const Array4< const Real > &	detJ,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv,
		const bool	do_lo
	)

Compute second-order advection tendencies for y-momentum tangent to an open boundary.

Parameters

[in]	bxy	box over which y-momentum is updated
[in]	dir	coordinate direction normal to the open boundary
[out]	rho_v_rhs	tendency for the y-momentum equation
[in]	v	y-component of velocity
[in]	rho_u	x-component of momentum
[in]	rho_v	y-component of momentum
[in]	Omega	component of momentum normal to the z-coordinate surface
[in]	ay	area fraction of y-faces
[in]	az	area fraction of z-faces
[in]	detJ	Jacobian of the metric transformation
[in]	cellSizeInv	inverse grid spacing
[in]	do_lo	flag for a low-side open boundary

{
    AMREX_ALWAYS_ASSERT(dir==0);
 
    auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
 
    ParallelFor(bxy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        if (ay(i,j,k) > zero) {
            Real yflux_hi = fourth * (rho_v(i  ,j+1,k) + rho_v(i  ,j  ,k)) * (v(i,j+1,k) + v(i,j,k)) * myhalf * (ay(i,j,k) + ay(i,j+1,k));
            Real yflux_lo = fourth * (rho_v(i  ,j  ,k) + rho_v(i  ,j-1,k)) * (v(i,j-1,k) + v(i,j,k)) * myhalf * (ay(i,j,k) + ay(i,j-1,k));
 
            Real zflux_hi = fourth * (Omega(i, j, k+1) + Omega(i, j-1, k+1)) * (v(i,j,k+1) + v(i,j,k)) * az(i,j,k+1);
            Real zflux_lo = fourth * (Omega(i, j, k  ) + Omega(i, j-1, k  )) * (v(i,j,k-1) + v(i,j,k)) * az(i,j,k  );
 
            Real x_src = AdvectionSrcForOpenBC_Tangent(i, j, k, 0, dir, v, rho_u, dxInv, do_lo);
            Real y_src = (yflux_hi - yflux_lo) * dyInv;
            Real z_src = (zflux_hi - zflux_lo) * dzInv;
            Real advectionSrc = x_src + y_src + z_src;
 
            rho_v_rhs(i, j, k) = -advectionSrc / (myhalf * (detJ(i,j,k) + detJ(i,j-1,k)));
        } else {
            rho_v_rhs(i, j, k) = zero;
        }
    });
}

Here is the call graph for this function:

AdvectionSrcForOpenBC_Tangent_Zmom()

void AdvectionSrcForOpenBC_Tangent_Zmom	(	const Box &	bxz,
		const OpenSide	x_side,
		const OpenSide	y_side,
		const Array4< Real > &	rho_w_rhs,
		const Array4< const Real > &	w,
		const Array4< const Real > &	rho_u,
		const Array4< const Real > &	rho_v,
		const Array4< const Real > &	Omega,
		const Array4< const Real > &	ax,
		const Array4< const Real > &	ay,
		const Array4< const Real > &	az,
		const Array4< const Real > &	detJ,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv,
		const int	domhi_z
	)

Compute second-order advection tendencies for z-momentum tangent to an open boundary.

Parameters

[in]	bxz	box over which z-momentum is updated
[in]	x_side	which x boundary the cells lie on, if any
[in]	y_side	which y boundary the cells lie on, if any
[out]	rho_w_rhs	tendency for the z-momentum equation
[in]	w	z-component of velocity
[in]	rho_u	x-component of momentum
[in]	rho_v	y-component of momentum
[in]	Omega	component of momentum normal to the z-coordinate surface
[in]	ax	area fraction of x-faces
[in]	ay	area fraction of y-faces
[in]	az	area fraction of z-faces
[in]	detJ	Jacobian of the metric transformation
[in]	cellSizeInv	inverse grid spacing
[in]	domhi_z	maximum cell-centered k-index in the domain

{
    // At a corner both sides are set, and neither x nor y may be differenced across
    const bool xopen   = (x_side != OpenSide::none);
    const bool yopen   = (y_side != OpenSide::none);
    const bool x_do_lo = (x_side == OpenSide::lo);
    const bool y_do_lo = (y_side == OpenSide::lo);
 
    AMREX_ALWAYS_ASSERT(xopen || yopen);
 
    auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
 
    ParallelFor(bxz, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        if (az(i,j,k) > zero) {
            Real xflux_hi = fourth*(rho_u(i+1,j  ,k) + rho_u(i+1, j, k-1)) * (w(i+1,j,k) + w(i,j,k)) *
                            myhalf *(ax(i+1,j,k) + ax(i+1,j,k-1));
 
            Real xflux_lo = fourth*(rho_u(i  ,j  ,k) + rho_u(i  , j, k-1)) * (w(i-1,j,k) + w(i,j,k)) *
                            myhalf *(ax(i,j,k) + ax(i,j,k-1));
 
            Real yflux_hi = fourth*(rho_v(i  ,j+1,k) + rho_v(i, j+1, k-1)) * (w(i,j+1,k) + w(i,j,k)) *
                            myhalf *(ay(i,j+1,k) + ay(i,j+1,k-1));
 
            Real yflux_lo = fourth*(rho_v(i  ,j  ,k) + rho_v(i, j  , k-1)) * (w(i,j-1,k) + w(i,j,k)) *
                            myhalf *(ay(i,j,k) + ay(i,j,k-1));
 
            Real zflux_lo = fourth * (Omega(i,j,k) + Omega(i,j,k-1)) * (w(i,j,k) + w(i,j,k-1)) *
                            myhalf *(az(i,j,k) + az(i,j,k-1));
 
            Real zflux_hi = (k == domhi_z+1) ? Omega(i,j,k) * w(i,j,k) * az(i,j,k):
                                               fourth * (Omega(i,j,k) + Omega(i,j,k+1)) * (w(i,j,k) + w(i,j,k+1)) *
                                               myhalf  * (az(i,j,k) + az(i,j,k+1));
 
            Real x_src = (xopen) ? AdvectionSrcForOpenBC_Tangent(i, j, k, 0, 0, w, rho_u, dxInv, x_do_lo) :
                                   (xflux_hi - xflux_lo) * dxInv;
            Real y_src = (yopen) ? AdvectionSrcForOpenBC_Tangent(i, j, k, 0, 1, w, rho_v, dyInv, y_do_lo) :
                                   (yflux_hi - yflux_lo) * dyInv;
            Real z_src = (zflux_hi - zflux_lo) * dzInv;
            Real advectionSrc = x_src + y_src + z_src;
 
            rho_w_rhs(i, j, k) = -advectionSrc / (myhalf*(detJ(i,j,k) + detJ(i,j,k-1)));
        } else {
            rho_w_rhs(i, j, k) = zero;
        }
    });
}

Here is the call graph for this function: