AmrLagrangeInterpolater.h

Go to the documentation of this file.

#ifndef AMR_LAGRANGE_INTERPOLATER_H
#define AMR_LAGRANGE_INTERPOLATER_H

#include "AmrInterpolater.h"

#if AMREX_SPACEDIM == 3
    #include <bitset>
    #include <iterator>
    #include <array>
#endif

#include "Ippl.h"

template <class Level>
class AmrLagrangeInterpolater : public AmrInterpolater<Level>
{
public:
    
    typedef typename Level::go_t        go_t;
    typedef typename Level::lo_t        lo_t;
    typedef typename Level::scalar_t    scalar_t;
    typedef typename Level::umap_t      umap_t;
    typedef typename Level::basefab_t   basefab_t;
    typedef amr::AmrIntVect_t           AmrIntVect_t;

    enum Order {
        LINEAR = 1,
        QUADRATIC
    };
    
#if AMREX_SPACEDIM == 3
    typedef std::bitset<25> qbits_t; 
    typedef std::bitset<9> lbits_t; 
    typedef std::array<unsigned int long, 9> qpattern_t;    
    typedef std::array<unsigned int long, 4> lpattern_t;    
#endif
    
public:
    
    AmrLagrangeInterpolater(Order order);
    
    void stencil(const AmrIntVect_t& iv,
                 const basefab_t& fab,
                 umap_t& map,
                 const scalar_t& scale,
                 Level* mglevel);
    
    void coarse(const AmrIntVect_t& iv,
                umap_t& map,
                const scalar_t& scale,
                lo_t dir, lo_t shift, const basefab_t& rfab,
                const AmrIntVect_t& riv,
                Level* mglevel);
    
    void fine(const AmrIntVect_t& iv,
              umap_t& map,
              const scalar_t& scale,
              lo_t dir, lo_t shift,
              Level* mglevel);
    
private:
    
    void fineLinear_m(const AmrIntVect_t& iv,
                      umap_t& map,
                      const scalar_t& scale,
                      lo_t dir, lo_t shift,
                      Level* mglevel);
    
    void fineQuadratic_m(const AmrIntVect_t& iv,
                         umap_t& map,
                         const scalar_t& scale,
                         lo_t dir, lo_t shift,
                         Level* mglevel);
    
    void crseLinear_m(const AmrIntVect_t& iv,
                      umap_t& map,
                      const scalar_t& scale,
                      lo_t dir, lo_t shift, const basefab_t& rfab,
                      const AmrIntVect_t& riv,
                      Level* mglevel);
    
    void crseQuadratic_m(const AmrIntVect_t& iv,
                         umap_t& map,
                         const scalar_t& scale,
                         lo_t dir, lo_t shift, const basefab_t& rfab,
                         const AmrIntVect_t& riv,
                         Level* mglevel);
    
private:
#if AMREX_SPACEDIM == 3
    static constexpr qpattern_t qpattern_ms {
        473536,                             
        14798,                              
        236768,                             
        15153152,                           
        947072,                             
        29596,                              
        7399,                               
        7576576,                            
        30306304                            
    };
    
    static constexpr lpattern_t lpattern_ms {
        27,                                 
        216,                                
        432,                                
        54                                  
    };
#endif

    // y_b   y_t
    static const scalar_t lookup1a_ms[2];
    static const scalar_t lookup2a_ms[2];
    static const scalar_t lookup1b_ms[2];
    static const scalar_t lookup2b_ms[2];
#if AMREX_SPACEDIM == 3
    static const scalar_t lookup3_ms[2];
    static const scalar_t lookup3r_ms[2];
    static const scalar_t lookup4_ms[2];
    static const scalar_t lookup4r_ms[2];
    static const scalar_t lookup5_ms[2];
    static const scalar_t lookup5r_ms[2];
    static const scalar_t lookup6_ms;
    static const scalar_t factor_ms;
#endif
};

#include "AmrLagrangeInterpolater.hpp"

#endif