Interpolation when implementing lattice Boltzmann Method with AMRex with AMR mesh strategy?

[lw5366]

I am trying to implement the lattice Boltzmann Method with AMRex taking advantage of its adaptive and efficient AMR mesh strategy.
According to my understanding, the AMRex directly interpolates the values from corarse mesh to finer mesh by using various interpolation methods such as bilinear interpolation, but there is a difference for the interpolation when using LBM and other FDM/FVM. Let's use a simple example to explain the difference, in the FDM/FVM, we may have
phi_finer_n = 0.5*(phi_coarse_m-1 + phi_coarse_m+1),
but in LBM, we may need to use
phi_finer_n = \alpha * 0.5*(phi_coarse_m-1 + phi_coarse_m+1),
where \alpha is a factor which needs to be computed based on some variables stored in phi. Therefore, my question is how we can achieve this easily.

Simply to say, we need another factor (\alpha) involved in the interpolation and average down, which seems not inherently supported by AMRex, how to achieve this easily with mimal change to the availabe code.

Thanks very much!

[WeiqunZhang]

You can write your own code to do this. Something like,

void interp (MultiFab const& coarse, MultiFab & fine, IntVect const& refratio)
{
    // Create a coarse version of the fine multifab.                                                                                                                         
    MultiFab cfine(amrex::convert(fine.boxArray(),refratio),
                   fine.DistributionMap(),
                   fine.nComp(), nghost); // nghost is zero or more depending on interpolation stencil.                                                                      

    // MPI communication from coarse to cfine.                                                                                                                               
    // May need to use FillPatch to fill ghost cells properly                                                                                                                
    cfine.ParallelCopy(coarse, 0, 0, cfine.nComp(), 0, nghost); 

    auto const& fa = fine.arrays();
    auto const& ca = cfine.const_arrays();
    ParallelFor(fine, [=] AMREX_GPU_DEVICE (int b, int i, int j, int k)
    {
        int ic = amrex::coarsen(i, refratio[0]);
        int jc = ...; int kc = ...;
        auto alpha = ...;
        fa[b](i,j,k) = alpha*(ca.....); 
    });
}

[lw5366]

Thanks very much for your reply. It seems that we can also take advantage of the post_interp function, which do something after the interpolation. In this way, we can keep using the default interpolation functions avaliable in Amrex.