ERF_ApplySpongeZoneBCs.cpp File Reference

#include <AMReX_MultiFab.H>
#include <ERF_SrcHeaders.H>

Include dependency graph for ERF_ApplySpongeZoneBCs.cpp:

Functions
void	ApplySpongeZoneBCsForCC (const SpongeChoice &spongeChoice, const Geometry geom, const Box &bx, const Array4< Real > &cell_rhs, const Array4< const Real > &cell_data, const Array4< const Real > &r0, const Array4< const Real > &th0, const Array4< const Real > &qv0, const Array4< const Real > &z_phys_cc, int n_qstate)
	Apply sponge zone damping to cell-centered state variables. More...
void	ApplySpongeZoneBCsForMom (const SpongeChoice &spongeChoice, const Geometry geom, const Box &tbx, const Box &tby, const Box &tbz, const Array4< Real > &rho_u_rhs, const Array4< Real > &rho_v_rhs, const Array4< Real > &rho_w_rhs, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &rho_w, const Array4< const Real > &r0, const Array4< const Real > &z_phys_nd, const Array4< const Real > &z_phys_cc)
	Apply sponge zone damping to momentum variables. More...

Function Documentation

ApplySpongeZoneBCsForCC()

void ApplySpongeZoneBCsForCC	(	const SpongeChoice &	spongeChoice,
		const Geometry	geom,
		const Box &	bx,
		const Array4< Real > &	cell_rhs,
		const Array4< const Real > &	cell_data,
		const Array4< const Real > &	r0,
		const Array4< const Real > &	th0,
		const Array4< const Real > &	qv0,
		const Array4< const Real > &	z_phys_cc,
		int	n_qstate
	)

Apply sponge zone damping to cell-centered state variables.

Parameters

[in]	spongeChoice	Sponge configuration.
[in]	geom	Domain geometry.
[in]	bx	Box of indices to process.
[in,out]	cell_rhs	Right-hand side for state variables.
[in]	cell_data	Current state data.
[in]	r0	Base state density.
[in]	th0	Base state potential temperature.
[in]	qv0	Base state moisture.
[in]	z_phys_cc	Cell-centered physical height.
[in]	n_qstate	Number of additional scalar state variables.

{
    // Domain cell size and real bounds
    auto dx = geom.CellSizeArray();
    auto ProbHiArr = geom.ProbHiArray();
    auto ProbLoArr = geom.ProbLoArray();
 
    const Real sponge_strength = spongeChoice.sponge_strength;
    const int use_xlo_sponge_damping = spongeChoice.use_xlo_sponge_damping;
    const int use_xhi_sponge_damping = spongeChoice.use_xhi_sponge_damping;
    const int use_ylo_sponge_damping = spongeChoice.use_ylo_sponge_damping;
    const int use_yhi_sponge_damping = spongeChoice.use_yhi_sponge_damping;
    const int use_zlo_sponge_damping = spongeChoice.use_zlo_sponge_damping;
    const int use_zhi_sponge_damping = spongeChoice.use_zhi_sponge_damping;
    if (!use_xlo_sponge_damping &&
        !use_xhi_sponge_damping &&
        !use_ylo_sponge_damping &&
        !use_yhi_sponge_damping &&
        !use_zlo_sponge_damping &&
        !use_zhi_sponge_damping)
        return;
 
    const Real xlo_sponge_end   = spongeChoice.xlo_sponge_end;
    const Real xhi_sponge_start = spongeChoice.xhi_sponge_start;
    const Real ylo_sponge_end   = spongeChoice.ylo_sponge_end;
    const Real yhi_sponge_start = spongeChoice.yhi_sponge_start;
    const Real zlo_sponge_end   = spongeChoice.zlo_sponge_end;
    const Real zhi_sponge_start = spongeChoice.zhi_sponge_start;
 
    const Real sponge_density_tmp = spongeChoice.sponge_density;
    const Real sponge_rhotheta_tmp = spongeChoice.sponge_rhotheta;
    const Real sponge_rhomoist_tmp = spongeChoice.sponge_rhomoist;
    const bool use_base_density = (sponge_density_tmp < zero);
    const bool use_base_rhotheta = (sponge_rhotheta_tmp < zero);
    const bool use_base_rhomoist = (sponge_rhomoist_tmp < zero);
 
    // Domain valid box
    const Box& domain = geom.Domain();
    int domlo_x = domain.smallEnd(0);
    int domhi_x = domain.bigEnd(0) + 1;
    int domlo_y = domain.smallEnd(1);
    int domhi_y = domain.bigEnd(1) + 1;
 
    if(use_xlo_sponge_damping)AMREX_ALWAYS_ASSERT(xlo_sponge_end   > ProbLoArr[0]);
    if(use_xhi_sponge_damping)AMREX_ALWAYS_ASSERT(xhi_sponge_start < ProbHiArr[0]);
    if(use_ylo_sponge_damping)AMREX_ALWAYS_ASSERT(ylo_sponge_end   > ProbLoArr[1]);
    if(use_yhi_sponge_damping)AMREX_ALWAYS_ASSERT(yhi_sponge_start < ProbHiArr[1]);
    if(use_zlo_sponge_damping)AMREX_ALWAYS_ASSERT(zlo_sponge_end   > ProbLoArr[2]);
    if(use_zhi_sponge_damping)AMREX_ALWAYS_ASSERT(zhi_sponge_start < ProbHiArr[2]);
 
    // Ramp lengths, computed here so that the kernels divide only by a valid length: the
    // optimiser evaluates the guarded ramps of the sides that are switched off too, and the
    // lengths of those sides (whose ends are never read from the inputs) can be zero
    const Real L_xlo = use_xlo_sponge_damping ? (xlo_sponge_end - ProbLoArr[0]) : one;
    const Real L_xhi = use_xhi_sponge_damping ? (ProbHiArr[0] - xhi_sponge_start) : one;
    const Real L_ylo = use_ylo_sponge_damping ? (ylo_sponge_end - ProbLoArr[1]) : one;
    const Real L_yhi = use_yhi_sponge_damping ? (ProbHiArr[1] - yhi_sponge_start) : one;
    const Real L_zlo = use_zlo_sponge_damping ? (zlo_sponge_end - ProbLoArr[2]) : one;
    const Real L_zhi = use_zhi_sponge_damping ? (ProbHiArr[2] - zhi_sponge_start) : one;
 
    ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
    {
        int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
        int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
 
        Real x = ProbLoArr[0] + (ii+myhalf) * dx[0];
        Real y = ProbLoArr[1] + (jj+myhalf) * dx[1];
        Real z = z_phys_cc(i,j,k);
 
        Real sponge_density = (use_base_density) ? r0(i,j,k) : sponge_density_tmp;
        Real sponge_rhotheta = (use_base_rhotheta) ? r0(i,j,k)*th0(i,j,k) : sponge_rhotheta_tmp;
        Real sponge_rhomoist = (use_base_rhomoist) ? r0(i,j,k)*qv0(i,j,k) : sponge_rhomoist_tmp;
 
        // x left sponge
        if(use_xlo_sponge_damping){
            if (x < xlo_sponge_end) {
                Real xi = (xlo_sponge_end - x) / L_xlo;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
        // x right sponge
        if(use_xhi_sponge_damping){
            if (x > xhi_sponge_start) {
                Real xi = (x - xhi_sponge_start) / L_xhi;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
 
        // y left sponge
        if(use_ylo_sponge_damping){
            if (y < ylo_sponge_end) {
                Real xi = (ylo_sponge_end - y) / L_ylo;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
        // x right sponge
        if(use_yhi_sponge_damping){
            if (y > yhi_sponge_start) {
                Real xi = (y - yhi_sponge_start) / L_yhi;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
 
        // x left sponge
        if(use_zlo_sponge_damping){
            if (z < zlo_sponge_end) {
                Real xi = (zlo_sponge_end - z) / L_zlo;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
        // x right sponge
        if(use_zhi_sponge_damping){
            if (z > zhi_sponge_start) {
                Real xi = (z - zhi_sponge_start) / L_zhi;
                cell_rhs(i, j, k, 0) -= sponge_strength * xi * xi * (cell_data(i, j, k, 0) - sponge_density);
                cell_rhs(i, j, k, 1) -= sponge_strength * xi * xi * (cell_data(i, j, k, 1) - sponge_rhotheta);
                if (n_qstate > 0) {
                    cell_rhs(i, j, k, RhoQ1_comp) -= sponge_strength * xi * xi * (cell_data(i, j, k, RhoQ1_comp) - sponge_rhomoist);
                    for (int n = RhoQ2_comp; n < RhoQ1_comp+n_qstate; ++n) {
                        cell_rhs(i, j, k, n) -= sponge_strength * xi * xi * cell_data(i, j, k, n);
                    }
                }
            }
        }
    });
}

Referenced by make_sources().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplySpongeZoneBCsForMom()

void ApplySpongeZoneBCsForMom	(	const SpongeChoice &	spongeChoice,
		const Geometry	geom,
		const Box &	tbx,
		const Box &	tby,
		const Box &	tbz,
		const Array4< Real > &	rho_u_rhs,
		const Array4< Real > &	rho_v_rhs,
		const Array4< Real > &	rho_w_rhs,
		const Array4< const Real > &	rho_u,
		const Array4< const Real > &	rho_v,
		const Array4< const Real > &	rho_w,
		const Array4< const Real > &	r0,
		const Array4< const Real > &	z_phys_nd,
		const Array4< const Real > &	z_phys_cc
	)

Apply sponge zone damping to momentum variables.

Parameters

[in]	spongeChoice	Sponge configuration.
[in]	geom	Domain geometry.
[in]	tbx	Processing box for x-momentum.
[in]	tby	Processing box for y-momentum.
[in]	tbz	Processing box for z-momentum.
[in,out]	rho_u_rhs	Right-hand side for x-momentum.
[in,out]	rho_v_rhs	Right-hand side for y-momentum.
[in,out]	rho_w_rhs	Right-hand side for z-momentum.
[in]	rho_u	Current x-momentum data.
[in]	rho_v	Current y-momentum data.
[in]	rho_w	Current z-momentum data.
[in]	r0	Base state density.
[in]	z_phys_nd	Node-centered physical height.
[in]	z_phys_cc	Cell-centered physical height.

{
    // Domain cell size and real bounds
    auto dx = geom.CellSizeArray();
    auto ProbHiArr = geom.ProbHiArray();
    auto ProbLoArr = geom.ProbLoArray();
 
    const Real sponge_strength = spongeChoice.sponge_strength;
    const int use_xlo_sponge_damping = spongeChoice.use_xlo_sponge_damping;
    const int use_xhi_sponge_damping = spongeChoice.use_xhi_sponge_damping;
    const int use_ylo_sponge_damping = spongeChoice.use_ylo_sponge_damping;
    const int use_yhi_sponge_damping = spongeChoice.use_yhi_sponge_damping;
    const int use_zlo_sponge_damping = spongeChoice.use_zlo_sponge_damping;
    const int use_zhi_sponge_damping = spongeChoice.use_zhi_sponge_damping;
    if (!use_xlo_sponge_damping &&
        !use_xhi_sponge_damping &&
        !use_ylo_sponge_damping &&
        !use_yhi_sponge_damping &&
        !use_zlo_sponge_damping &&
        !use_zhi_sponge_damping)
        return;
 
    const Real xlo_sponge_end   = spongeChoice.xlo_sponge_end;
    const Real xhi_sponge_start = spongeChoice.xhi_sponge_start;
    const Real ylo_sponge_end   = spongeChoice.ylo_sponge_end;
    const Real yhi_sponge_start = spongeChoice.yhi_sponge_start;
    const Real zlo_sponge_end   = spongeChoice.zlo_sponge_end;
    const Real zhi_sponge_start = spongeChoice.zhi_sponge_start;
 
    const Real sponge_x_velocity = spongeChoice.sponge_x_velocity;
    const Real sponge_y_velocity = spongeChoice.sponge_y_velocity;
    const Real sponge_z_velocity = spongeChoice.sponge_z_velocity;
 
    const Real sponge_density_tmp = spongeChoice.sponge_density;
    const bool use_base = (sponge_density_tmp < zero);
 
    // Domain valid box
    const Box& domain = geom.Domain();
    int domlo_x = domain.smallEnd(0);
    int domhi_x = domain.bigEnd(0) + 1;
    int domlo_y = domain.smallEnd(1);
    int domhi_y = domain.bigEnd(1) + 1;
 
    if(use_xlo_sponge_damping)AMREX_ALWAYS_ASSERT(xlo_sponge_end   > ProbLoArr[0]);
    if(use_xhi_sponge_damping)AMREX_ALWAYS_ASSERT(xhi_sponge_start < ProbHiArr[0]);
    if(use_ylo_sponge_damping)AMREX_ALWAYS_ASSERT(ylo_sponge_end   > ProbLoArr[1]);
    if(use_yhi_sponge_damping)AMREX_ALWAYS_ASSERT(yhi_sponge_start < ProbHiArr[1]);
    if(use_zlo_sponge_damping)AMREX_ALWAYS_ASSERT(zlo_sponge_end   > ProbLoArr[2]);
    if(use_zhi_sponge_damping)AMREX_ALWAYS_ASSERT(zhi_sponge_start < ProbHiArr[2]);
 
    // Ramp lengths, computed here so that the kernels divide only by a valid length: the
    // optimiser evaluates the guarded ramps of the sides that are switched off too, and the
    // lengths of those sides (whose ends are never read from the inputs) can be zero
    const Real L_xlo = use_xlo_sponge_damping ? (xlo_sponge_end - ProbLoArr[0]) : one;
    const Real L_xhi = use_xhi_sponge_damping ? (ProbHiArr[0] - xhi_sponge_start) : one;
    const Real L_ylo = use_ylo_sponge_damping ? (ylo_sponge_end - ProbLoArr[1]) : one;
    const Real L_yhi = use_yhi_sponge_damping ? (ProbHiArr[1] - yhi_sponge_start) : one;
    const Real L_zlo = use_zlo_sponge_damping ? (zlo_sponge_end - ProbLoArr[2]) : one;
    const Real L_zhi = use_zhi_sponge_damping ? (ProbHiArr[2] - zhi_sponge_start) : one;
 
    ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
    {
        int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
        int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
 
        Real x = ProbLoArr[0] + ii * dx[0];
        Real y = ProbLoArr[1] + (jj+myhalf) * dx[1];
        // Height of the x-face
        Real z = myhalf * (z_phys_cc(i-1,j,k) + z_phys_cc(i,j,k));
 
        Real sponge_density = (use_base) ? myhalf * (r0(i,j,k) + r0(i-1,j,k)) : sponge_density_tmp;
 
        // x lo sponge
        if(use_xlo_sponge_damping){
            if (x < xlo_sponge_end) {
                Real xi = (xlo_sponge_end - x) / L_xlo;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
        // x hi sponge
        if(use_xhi_sponge_damping){
            if (x > xhi_sponge_start) {
                Real xi = (x - xhi_sponge_start) / L_xhi;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
 
        // y lo sponge
        if(use_ylo_sponge_damping){
            if (y < ylo_sponge_end) {
                Real xi = (ylo_sponge_end - y) / L_ylo;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
        // x right sponge
        if(use_yhi_sponge_damping){
            if (y > yhi_sponge_start) {
                Real xi = (y - yhi_sponge_start) / L_yhi;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
 
        // z lo sponge
        if(use_zlo_sponge_damping){
            if (z < zlo_sponge_end) {
                Real xi = (zlo_sponge_end - z) / L_zlo;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
 
 
        // z hi sponge
        if(use_zhi_sponge_damping){
            if (z > zhi_sponge_start) {
                Real xi = (z - zhi_sponge_start) / L_zhi;
                rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - sponge_density*sponge_x_velocity);
            }
        }
    });
 
 
    ParallelFor(tby, [=] AMREX_GPU_DEVICE(int i, int j, int k)
    {
        int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
        int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
 
        Real x = ProbLoArr[0] + (ii+myhalf) * dx[0];
        Real y = ProbLoArr[1] + jj * dx[1];
        // Height of the y-face
        Real z = myhalf * (z_phys_cc(i,j-1,k) + z_phys_cc(i,j,k));
 
        Real sponge_density = (use_base) ?  myhalf * (r0(i,j,k) + r0(i,j-1,k)) : sponge_density_tmp;
 
        // x lo sponge
        if(use_xlo_sponge_damping){
            if (x < xlo_sponge_end) {
                Real xi = (xlo_sponge_end - x) / L_xlo;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
        // x hi sponge
        if(use_xhi_sponge_damping){
            if (x > xhi_sponge_start) {
                Real xi = (x - xhi_sponge_start) / L_xhi;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
 
        // y lo sponge
        if(use_ylo_sponge_damping){
            if (y < ylo_sponge_end) {
                Real xi = (ylo_sponge_end - y) / L_ylo;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
        // x right sponge
        if(use_yhi_sponge_damping){
            if (y > yhi_sponge_start) {
                Real xi = (y - yhi_sponge_start) / L_yhi;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
 
        // z lo sponge
        if(use_zlo_sponge_damping){
            if (z < zlo_sponge_end) {
                Real xi = (zlo_sponge_end - z) / L_zlo;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
 
 
        // z hi sponge
        if(use_zhi_sponge_damping){
            if (z > zhi_sponge_start) {
                Real xi = (z - zhi_sponge_start) / L_zhi;
                rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - sponge_density*sponge_y_velocity);
            }
        }
    });
 
 
    ParallelFor(tbz, [=] AMREX_GPU_DEVICE(int i, int j, int k)
    {
        int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
        int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
 
        Real x = ProbLoArr[0] + (ii+myhalf) * dx[0];
        Real y = ProbLoArr[1] + (jj+myhalf) * dx[1];
        // Height of the z-face centre: average of its four corner nodes, taken in pairs
        // so that equal corner heights (no terrain) give back that height exactly
        Real z = myhalf * ( myhalf * (z_phys_nd(i,j  ,k) + z_phys_nd(i+1,j  ,k))
                          + myhalf * (z_phys_nd(i,j+1,k) + z_phys_nd(i+1,j+1,k)) );
 
        Real sponge_density = (use_base) ? myhalf * (r0(i,j,k) + r0(i,j,k-1)) : sponge_density_tmp;
 
        // x left sponge
        if(use_xlo_sponge_damping){
            if (x < xlo_sponge_end) {
                Real xi = (xlo_sponge_end - x) / L_xlo;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
        // x right sponge
        if(use_xhi_sponge_damping){
            if (x > xhi_sponge_start) {
                Real xi = (x - xhi_sponge_start) / L_xhi;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
 
        // y lo sponge
        if(use_ylo_sponge_damping){
            if (y < ylo_sponge_end) {
                Real xi = (ylo_sponge_end - y) / L_ylo;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
        // x right sponge
        if(use_yhi_sponge_damping){
            if (y > yhi_sponge_start) {
                Real xi = (y - yhi_sponge_start) / L_yhi;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
 
        // z lo sponge
        if(use_zlo_sponge_damping){
            if (z < zlo_sponge_end) {
                Real xi = (zlo_sponge_end - z) / L_zlo;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
 
 
        // z top sponge
        if(use_zhi_sponge_damping){
            if (z > zhi_sponge_start) {
                Real xi = (z - zhi_sponge_start) / L_zhi;
                rho_w_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_w(i, j, k) - sponge_density*sponge_z_velocity);
            }
        }
    });
}

Referenced by make_mom_sources().

Here is the call graph for this function:

Here is the caller graph for this function: