AmrMultiGridLevel.h

Go to the documentation of this file.

#ifndef AMR_MULTI_GRID_LEVEL
#define AMR_MULTI_GRID_LEVEL

#include <vector>

#include <AMReX_IntVect.H>

#include "Ippl.h"

#include "AmrMultiGridDefs.h"

#include <unordered_map>

template <class MatrixType, class VectorType>
class AmrMultiGridLevel {
    
public:
    typedef amr::AmrField_t             AmrField_t;
    typedef amr::AmrGeometry_t          AmrGeometry_t;
    typedef std::unique_ptr<AmrField_t> AmrField_u;
    typedef std::shared_ptr<AmrField_t> AmrField_s;
    typedef amr::AmrIntVect_t           AmrIntVect_t;
    typedef MatrixType                  matrix_t;
    typedef VectorType                  vector_t;
    typedef amrex::BaseFab<int>         basefab_t;
    typedef amrex::FabArray<basefab_t>  mask_t;
    typedef std::shared_ptr<AmrBoundary<AmrMultiGridLevel<MatrixType,
                                                          VectorType
                                                          >
                                        >
                            > boundary_t;
    
    typedef amr::comm_t comm_t;
    typedef amr::dmap_t dmap_t;
    typedef amr::node_t node_t;
    typedef amr::global_ordinal_t go_t;
    typedef amr::scalar_t scalar_t;
    typedef amr::local_ordinal_t lo_t;
    
    typedef std::vector<go_t> indices_t;
    
    typedef std::vector<scalar_t> coefficients_t;
    
    // Type with matrix index (column) and coefficient value
    typedef std::unordered_map<go_t, scalar_t> umap_t;
    
    // covered   : ghost cells covered by valid cells of this FabArray
    //             (including periodically shifted valid cells)
    // notcovered: ghost cells not covered by valid cells
    //             (including ghost cells outside periodic boundaries) (BNDRY)
    // physbnd   : boundary cells outside the domain (excluding periodic boundaries)
    // interior  : interior cells (i.e., valid cells)
    enum Mask {
        COVERED   = -1,
        INTERIOR  =  0,
        BNDRY     =  1,
        PHYSBNDRY =  2
    };

    // NO   : not a refined cell 
    // YES  : cell got refined
    enum Refined {
        YES = 0,
        NO  = 1
    };
    
public:
    AmrMultiGridLevel(const Vector_t& meshScaling,
                      const amrex::BoxArray& _grids,
                      const amrex::DistributionMapping& _dmap,
                      const AmrGeometry_t& _geom,
                      const AmrIntVect_t& rr,
                      const boundary_t* bc,
                      const Teuchos::RCP<comm_t>& comm,
                      const Teuchos::RCP<node_t>& node);
    
    ~AmrMultiGridLevel();
    
    go_t serialize(const AmrIntVect_t& iv) const;
    
    bool isBoundary(const AmrIntVect_t& iv) const;
    
    bool applyBoundary(const AmrIntVect_t& iv,
                       umap_t& map,
                       const scalar_t& value);
    
    bool applyBoundary(const AmrIntVect_t& iv,
                       const basefab_t& fab,
                       umap_t& map,
                       const scalar_t& value);
    
    void applyBoundary(const AmrIntVect_t& iv,
                       const lo_t& dir,
                       umap_t& map,
                       const scalar_t& value);
    
    const AmrIntVect_t& refinement() const;
    
    const scalar_t* cellSize() const;
    
    const scalar_t& cellSize(lo_t dir) const;
    
    const scalar_t* invCellSize() const;
    
    const scalar_t& invCellSize(lo_t dir) const;

    bool isValid(const AmrIntVect_t& iv) const;

    void buildLevelMask();

private:
    void buildMap(const Teuchos::RCP<comm_t>& comm,
                  const Teuchos::RCP<node_t>& node);
    
public:
    const amrex::BoxArray& grids;           
    const amrex::DistributionMapping& dmap; 
    const AmrGeometry_t& geom;              
    
    Teuchos::RCP<dmap_t> map_p;         
    
    Teuchos::RCP<matrix_t> Anf_p;       
    Teuchos::RCP<matrix_t> R_p;         
    Teuchos::RCP<matrix_t> I_p;         
    Teuchos::RCP<matrix_t> Bcrse_p;     
    Teuchos::RCP<matrix_t> Bfine_p;     
    Teuchos::RCP<matrix_t> Awf_p;       
    
    Teuchos::RCP<matrix_t> G_p[AMREX_SPACEDIM];
    
    Teuchos::RCP<vector_t> rho_p;       
    Teuchos::RCP<vector_t> phi_p;       
    Teuchos::RCP<vector_t> residual_p;  
    Teuchos::RCP<vector_t> error_p;     
    Teuchos::RCP<matrix_t> UnCovered_p; 
    
    std::unique_ptr<mask_t> mask;       
    std::unique_ptr<mask_t> refmask;    
    std::unique_ptr<mask_t> crsemask;
    
private:
    go_t nr_m[AMREX_SPACEDIM];          
    
    AmrIntVect_t rr_m;                  
    
    boundary_t bc_mp[AMREX_SPACEDIM];   
    
    scalar_t dx_m[AMREX_SPACEDIM];      
    scalar_t invdx_m[AMREX_SPACEDIM];   
};


#include "AmrMultiGridLevel.hpp"

#endif