AmrLagrangeInterpolater.h

Go to the documentation of this file.

//
// Class AmrLagrangeInterpolater
//   Lagrange interpolation for coarse-fine interfaces.
//
// Copyright (c) 2017 - 2020, Matthias Frey, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// Implemented as part of the PhD thesis
// "Precise Simulations of Multibunches in High Intensity Cyclotrons"
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#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