average.H

Go to the documentation of this file.

/* Copyright 2022 Edoardo Zoni, Remi Lehe, Prabhat Kumar, Axel Huebl
 *
 * This file is part of ABLASTR.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef ABLASTR_COARSEN_AVERAGE_H_
#define ABLASTR_COARSEN_AVERAGE_H_
 
 
#include <AMReX_Array.H>
#include <AMReX_Array4.H>
#include <AMReX_BLassert.H>
#include <AMReX_Extension.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_IntVect.H>
#include <AMReX_Math.H>
#include <AMReX_REAL.H>
 
#include <AMReX_BaseFwd.H>
 
#include <cstdlib>
 
 
namespace ablastr::coarsen::average
{
    AMREX_GPU_DEVICE
    AMREX_FORCE_INLINE
    amrex::Real
    Interp (
        amrex::Array4<amrex::Real const> const &arr_src,
        amrex::GpuArray<int, 3> const &sf,
        amrex::GpuArray<int, 3> const &sc,
        amrex::GpuArray<int, 3> const &cr,
        int const i,
        int const j,
        int const k,
        int const comp
    )
    {
        using namespace amrex::literals;
 
        AMREX_ASSERT_WITH_MESSAGE(sf[0] == sc[0], "Interp: Staggering for component 0 does not match!");
        AMREX_ASSERT_WITH_MESSAGE(sf[1] == sc[1], "Interp: Staggering for component 1 does not match!");
        AMREX_ASSERT_WITH_MESSAGE(sf[2] == sc[2], "Interp: Staggering for component 2 does not match!");
 
        // Indices of destination array (coarse)
        int const ic[3] = {i, j, k};
 
        // Number of points and starting indices of source array (fine)
        int np[3], idx_min[3];
 
        // Compute number of points
        for (int l = 0; l < 3; ++l) {
            if (cr[l] == 1)
                np[l] = 1; // no coarsening
            else
                np[l] = cr[l] * (1 - sf[l]) * (1 - sc[l])        // cell-centered
                        + (2 * (cr[l] - 1) + 1) * sf[l] * sc[l]; // nodal
        }
 
        // Compute starting indices of source array (fine)
        for (int l = 0; l < 3; ++l) {
            if (cr[l] == 1)
                idx_min[l] = ic[l]; // no coarsening
            else
                idx_min[l] = ic[l] * cr[l] * (1 - sf[l]) * (1 - sc[l])      // cell-centered
                             + (ic[l] * cr[l] - cr[l] + 1) * sf[l] * sc[l]; // nodal
        }
 
        // Auxiliary integer variables
        int const numx = np[0];
        int const numy = np[1];
        int const numz = np[2];
        int const imin = idx_min[0];
        int const jmin = idx_min[1];
        int const kmin = idx_min[2];
        int const sfx = sf[0];
        int const sfy = sf[1];
        int const sfz = sf[2];
        int const scx = sc[0];
        int const scy = sc[1];
        int const scz = sc[2];
        int const crx = cr[0];
        int const cry = cr[1];
        int const crz = cr[2];
        int ii, jj, kk;
        amrex::Real wx, wy, wz;
 
        // Add neutral elements (=0) beyond guard cells in source array (fine)
        auto const arr_src_safe = [arr_src]
                AMREX_GPU_DEVICE(int const ix, int const iy, int const iz, int const n) noexcept {
            return arr_src.contains(ix, iy, iz) ? arr_src(ix, iy, iz, n) : 0.0_rt;
        };
 
        // Interpolate over points computed above. Weights are computed in order
        // to guarantee total charge conservation for both cell-centered data
        // (equal weights) and nodal data (weights depend on distance between
        // points on fine and coarse grids). Terms multiplied by (1-sf)*(1-sc)
        // are ON for cell-centered data and OFF for nodal data, while terms
        // multiplied by sf*sc are ON for nodal data and OFF for cell-centered data.
        // Python script Source/Utils/check_interp_points_and_weights.py can be
        // used to check interpolation points and weights in 1D.
        amrex::Real c = 0.0_rt;
        for (int kref = 0; kref < numz; ++kref) {
            for (int jref = 0; jref < numy; ++jref) {
                for (int iref = 0; iref < numx; ++iref) {
                    ii = imin + iref;
                    jj = jmin + jref;
                    kk = kmin + kref;
                    wx = (1.0_rt / static_cast<amrex::Real>(numx)) * (1 - sfx) * (1 - scx) // if cell-centered
                         + ((amrex::Math::abs(crx - amrex::Math::abs(ii - i * crx))) /
                            static_cast<amrex::Real>(crx * crx)) * sfx * scx; // if nodal
                    wy = (1.0_rt / static_cast<amrex::Real>(numy)) * (1 - sfy) * (1 - scy) // if cell-centered
                         + ((amrex::Math::abs(cry - amrex::Math::abs(jj - j * cry))) /
                            static_cast<amrex::Real>(cry * cry)) * sfy * scy; // if nodal
                    wz = (1.0_rt / static_cast<amrex::Real>(numz)) * (1 - sfz) * (1 - scz) // if cell-centered
                         + ((amrex::Math::abs(crz - amrex::Math::abs(kk - k * crz))) /
                            static_cast<amrex::Real>(crz * crz)) * sfz * scz; // if nodal
                    c += wx * wy * wz * arr_src_safe(ii, jj, kk, comp);
                }
            }
        }
        return c;
    }
 
    void
    Loop (
        amrex::MultiFab & mf_dst,
        amrex::MultiFab const & mf_src,
        int const ncomp,
        amrex::IntVect const ngrow,
        amrex::IntVect const crse_ratio
    );
 
    void
    Coarsen (
        amrex::MultiFab & mf_dst,
        amrex::MultiFab const & mf_src,
        amrex::IntVect const crse_ratio
    );
 
} // namespace ablastr::coarsen::average
 
#endif // ABLASTR_COARSEN_AVERAGE_H_