ERF_ThinBodyWallDist.cpp File Reference

#include <AMReX.H>
#include <AMReX_MultiFab.H>

Include dependency graph for ERF_ThinBodyWallDist.cpp:

Functions
void	thinbody_wall_dist (std::unique_ptr< MultiFab > &wdist, Vector< IntVect > &xfaces, Vector< IntVect > &yfaces, Vector< IntVect > &zfaces, const Geometry &geomdata, std::unique_ptr< MultiFab > &z_phys_cc)

Function Documentation

thinbody_wall_dist()

void thinbody_wall_dist	(	std::unique_ptr< MultiFab > &	wdist,
		Vector< IntVect > &	xfaces,
		Vector< IntVect > &	yfaces,
		Vector< IntVect > &	zfaces,
		const Geometry &	geomdata,
		std::unique_ptr< MultiFab > &	z_phys_cc
	)

{
    BL_PROFILE("thinbody_wall_dist()");
 
    const auto prob_lo = geomdata.ProbLoArray();
    const auto dx      = geomdata.CellSizeArray();
 
    const bool use_terrain = (z_phys_cc != nullptr);
    if (use_terrain) {
        Error("Thinbody wall dist calc not implemented for terrain yet");
    }
 
    Gpu::DeviceVector<IntVect> xfaces_d(xfaces.size());
    Gpu::DeviceVector<IntVect> yfaces_d(yfaces.size());
    Gpu::DeviceVector<IntVect> zfaces_d(zfaces.size());
    Gpu::copyAsync(Gpu::hostToDevice, xfaces.begin(), xfaces.end(), xfaces_d.begin());
    Gpu::copyAsync(Gpu::hostToDevice, yfaces.begin(), yfaces.end(), yfaces_d.begin());
    Gpu::copyAsync(Gpu::hostToDevice, zfaces.begin(), zfaces.end(), zfaces_d.begin());
    auto const* xfaces_d_ptr = xfaces_d.data();
    auto const* yfaces_d_ptr = yfaces_d.data();
    auto const* zfaces_d_ptr = zfaces_d.data();
    const auto n_xfaces = xfaces_d.size();
    const auto n_yfaces = yfaces_d.size();
    const auto n_zfaces = zfaces_d.size();
 
    for (MFIter mfi(*wdist); mfi.isValid(); ++mfi) {
        const Box& bx = mfi.validbox();
 
        //const auto& z_cc = (use_terrain) ? z_phys_cc->const_array(mfi) : Array4<const Real>{};
        auto wd_arr      = wdist->array(mfi);
 
        if (!use_terrain) {
            ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) {
                Real xr = prob_lo[0] + (i + Real(0.5)) * dx[0];
                Real yr = prob_lo[1] + (j + Real(0.5)) * dx[1];
                Real zr = prob_lo[2] + (k + Real(0.5)) * dx[2];
 
                for (std::size_t iface=0; iface < n_xfaces; ++iface) {
                    int ii = xfaces_d_ptr[iface][0];
                    int jj = xfaces_d_ptr[iface][1];
                    int kk = xfaces_d_ptr[iface][2];
                    Real xfc = prob_lo[0] +  ii            * dx[0];
                    Real y0  = prob_lo[1] +  jj            * dx[1];
                    Real y1  = prob_lo[1] + (jj+1)         * dx[1];
                    Real z0  = prob_lo[2] +  kk            * dx[2];
                    Real z1  = prob_lo[2] + (kk+1)         * dx[2];
                    // Nearest point of the face: the cell centre clamped onto the rectangle
                    Real yn  = amrex::min(amrex::max(yr, y0), y1);
                    Real zn  = amrex::min(amrex::max(zr, z0), z1);
                    Real wd2 = wd_arr(i, j, k) * wd_arr(i, j, k);
                    wd2 = min(wd2, (xfc-xr)*(xfc-xr) + (yn-yr)*(yn-yr) + (zn-zr)*(zn-zr));
                    wd_arr(i, j, k) = std::sqrt(wd2);
                }
 
                for (std::size_t iface=0; iface < n_yfaces; ++iface) {
                    int ii = yfaces_d_ptr[iface][0];
                    int jj = yfaces_d_ptr[iface][1];
                    int kk = yfaces_d_ptr[iface][2];
                    Real yfc = prob_lo[1] +  jj            * dx[1];
                    Real x0  = prob_lo[0] +  ii            * dx[0];
                    Real x1  = prob_lo[0] + (ii+1)         * dx[0];
                    Real z0  = prob_lo[2] +  kk            * dx[2];
                    Real z1  = prob_lo[2] + (kk+1)         * dx[2];
                    // Nearest point of the face: the cell centre clamped onto the rectangle
                    Real xn  = amrex::min(amrex::max(xr, x0), x1);
                    Real zn  = amrex::min(amrex::max(zr, z0), z1);
                    Real wd2 = wd_arr(i, j, k) * wd_arr(i, j, k);
                    wd2 = min(wd2, (xn-xr)*(xn-xr) + (yfc-yr)*(yfc-yr) + (zn-zr)*(zn-zr));
                    wd_arr(i, j, k) = std::sqrt(wd2);
                }
 
                for (std::size_t iface=0; iface < n_zfaces; ++iface) {
                    int ii = zfaces_d_ptr[iface][0];
                    int jj = zfaces_d_ptr[iface][1];
                    int kk = zfaces_d_ptr[iface][2];
                    Real zfc = prob_lo[2] +  kk            * dx[2];
                    Real x0  = prob_lo[0] +  ii            * dx[0];
                    Real x1  = prob_lo[0] + (ii+1)         * dx[0];
                    Real y0  = prob_lo[1] +  jj            * dx[1];
                    Real y1  = prob_lo[1] + (jj+1)         * dx[1];
                    // Nearest point of the face: the cell centre clamped onto the rectangle
                    Real xn  = amrex::min(amrex::max(xr, x0), x1);
                    Real yn  = amrex::min(amrex::max(yr, y0), y1);
                    Real wd2 = wd_arr(i, j, k) * wd_arr(i, j, k);
                    wd2 = min(wd2, (xn-xr)*(xn-xr) + (yn-yr)*(yn-yr) + (zfc-zr)*(zfc-zr));
                    wd_arr(i, j, k) = std::sqrt(wd2);
                }
            });
        }
    }
}

Referenced by ERF::make_wall_dist().

Here is the call graph for this function:

Here is the caller graph for this function: