AmrMultiGridLevel.h

Go to the documentation of this file.

//
// Class AmrMultiGridLevel
//   This class represents a single AMR level, i.e. it stores all matrices
//   and vectors of a level.
//
// 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_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::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);
    
    ~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);
    
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