AMReX_AmrMesh.H

Go to the documentation of this file.

#ifndef BL_AMRMESH_H_
#define BL_AMRMESH_H_
#include <AMReX_Config.H>
 
#include <AMReX_Array.H>
#include <AMReX_Vector.H>
#include <AMReX_RealBox.H>
#include <AMReX_IntVect.H>
#include <AMReX_Geometry.H>
#include <AMReX_DistributionMapping.H>
#include <AMReX_BoxArray.H>
#include <AMReX_TagBox.H>
 
#ifdef AMREX_USE_BITTREE
#include <Bittree_BittreeAmr.h>
#endif
 
namespace amrex {
 
struct AmrInfo {
    int verbose = 0;
    int max_level = 0;
    Vector<IntVect> ref_ratio {{IntVect(2)}};
    Vector<IntVect> blocking_factor {{IntVect(8)}};
#if defined(AMREX_USE_GPU)
    Vector<IntVect> max_grid_size {{IntVect(AMREX_D_PICK(128,128,64))}};
#else
    Vector<IntVect> max_grid_size {{IntVect(AMREX_D_PICK(128,128,32))}};
#endif
    Vector<IntVect> n_error_buf {{IntVect(1)}};
    Real grid_eff = static_cast<Real>(0.7);
    int n_proper = 1;
    int use_fixed_upto_level = 0;
    bool use_fixed_coarse_grids = false;
 
    bool refine_grid_layout = true;
 
    IntVect refine_grid_layout_dims = IntVect(1);
 
    bool check_input = true;
    bool use_new_chop = false;
    bool iterate_on_new_grids = true;
    int max_grid_iterations = 4;
};
 
class AmrMesh
    : protected AmrInfo
{
public:
 
    friend std::ostream& operator<< (std::ostream& os, AmrMesh const& amr_mesh);
 
    AmrMesh ();
 
    AmrMesh (const RealBox* rb, int max_level_in,
             const Vector<int>& n_cell_in, int coord=-1,
             Vector<IntVect> refrat = Vector<IntVect>(),
             const int* is_per = nullptr);
 
    AmrMesh (const RealBox& rb, int max_level_in,
             const Vector<int>& n_cell_in, int coord,
             Vector<IntVect> const& a_refrat,
             Array<int,AMREX_SPACEDIM> const& is_per);
 
    AmrMesh (Geometry const& level_0_geom, AmrInfo const& amr_info);
 
    AmrMesh (const AmrMesh& rhs) = delete;
    AmrMesh& operator= (const AmrMesh& rhs) = delete;
 
    AmrMesh (AmrMesh&& rhs) = default;
    AmrMesh& operator= (AmrMesh&& rhs) = default;
 
    virtual ~AmrMesh () = default;
 
    [[nodiscard]] int Verbose () const noexcept { return verbose; }
 
    [[nodiscard]] int maxLevel () const noexcept { return max_level; }
 
    [[nodiscard]] int finestLevel () const noexcept { return finest_level; }
 
    [[nodiscard]] IntVect refRatio (int lev) const noexcept { return ref_ratio[lev]; }
 
    [[nodiscard]] int MaxRefRatio (int lev) const noexcept;
 
    [[nodiscard]] const Vector<IntVect>& refRatio () const noexcept { return ref_ratio; }
 
    [[nodiscard]] const Vector<Geometry>& Geom () const noexcept { return geom; }
    [[nodiscard]] const Vector<DistributionMapping>& DistributionMap () const noexcept { return dmap; }
    [[nodiscard]] const Vector<BoxArray>& boxArray () const noexcept { return grids; }
 
    [[nodiscard]] const Geometry& Geom (int lev) const noexcept { return geom[lev]; }
    [[nodiscard]] const DistributionMapping& DistributionMap (int lev) const noexcept { return dmap[lev]; }
    [[nodiscard]] const BoxArray& boxArray (int lev) const noexcept { return grids[lev]; }
 
    [[nodiscard]] Vector<Geometry> Geom (int a_coarsest_lev, int a_finest_lev) const noexcept {
        Vector<Geometry> r;
        r.reserve(a_finest_lev-a_coarsest_lev+1);
        for (int lev = a_coarsest_lev; lev <= a_finest_lev; ++lev) {
            r.push_back(geom[lev]);
        }
        return r;
    }
    [[nodiscard]] Vector<BoxArray> boxArray (int a_coarsest_lev, int a_finest_lev) const noexcept {
        Vector<BoxArray> r;
        r.reserve(a_finest_lev-a_coarsest_lev+1);
        for (int lev = a_coarsest_lev; lev <= a_finest_lev; ++lev) {
            r.push_back(grids[lev]);
        }
        return r;
    }
    [[nodiscard]] Vector<DistributionMapping> DistributionMap (int a_coarsest_lev, int a_finest_lev) const noexcept {
        Vector<DistributionMapping> r;
        r.reserve(a_finest_lev-a_coarsest_lev+1);
        for (int lev = a_coarsest_lev; lev <= a_finest_lev; ++lev) {
            r.push_back(dmap[lev]);
        }
        return r;
    }
 
    Vector<Geometry>& Geom () noexcept { return geom; }
    Geometry& Geom (int lev) noexcept { return geom[lev]; }
 
    void SetMaxGridSize (int new_mgs) noexcept {
        max_grid_size.assign(max_level+1, IntVect{AMREX_D_DECL(new_mgs,new_mgs,new_mgs)});
    }
    void SetMaxGridSize (const IntVect& new_mgs) noexcept {
        max_grid_size.assign(max_level+1, new_mgs);
    }
    void SetMaxGridSize (const Vector<int>& new_mgs) noexcept {
        max_grid_size.resize(max_level+1);
        for (int i = 0; i <= max_level; ++i) {
            max_grid_size[i] = IntVect{AMREX_D_DECL(new_mgs[i],new_mgs[i],new_mgs[i])};
        }
    }
    void SetMaxGridSize (const Vector<IntVect>& new_mgs) noexcept {
        max_grid_size.assign(new_mgs.cbegin(), new_mgs.cbegin()+max_level+1);
    }
 
    void SetBlockingFactor (int new_bf) noexcept {
        blocking_factor.assign(max_level+1, IntVect{AMREX_D_DECL(new_bf,new_bf,new_bf)});
    }
    void SetBlockingFactor (const IntVect& new_bf) noexcept {
        blocking_factor.assign(max_level+1, new_bf);
    }
    void SetBlockingFactor (const Vector<int>& new_bf) noexcept {
        blocking_factor.resize(max_level+1);
        for (int i = 0; i <= max_level; ++i) {
            blocking_factor[i] = IntVect{AMREX_D_DECL(new_bf[i],new_bf[i],new_bf[i])};
        }
    }
    void SetBlockingFactor (const Vector<IntVect>& new_bf) noexcept {
        AMREX_ALWAYS_ASSERT(new_bf.size() >= (max_level+1));
        blocking_factor.assign(new_bf.cbegin(), new_bf.cbegin()+max_level+1);
    }
 
    void SetGridEff (Real eff) noexcept { grid_eff = eff; }
 
    void SetNProper (int n) noexcept { n_proper = n; }
 
    // There is no set for ref_ratio because it would require rebuilding Geometry objects.
 
    void SetFinestLevel (int new_finest_level) noexcept { finest_level = new_finest_level; }
    void SetDistributionMap (int lev, const DistributionMapping& dmap_in) noexcept;
 
    void SetBoxArray (int lev, const BoxArray& ba_in) noexcept;
 
    void SetGeometry (int lev, const Geometry& geom_in) noexcept;
 
    [[nodiscard]] int GetLevel (Box const& domain) const noexcept;
 
    void ClearDistributionMap (int lev) noexcept;
    void ClearBoxArray (int lev) noexcept;
 
    [[nodiscard]] int nErrorBuf (int lev, int direction = 0) const noexcept { return n_error_buf[lev][direction]; }
 
    [[nodiscard]] const IntVect& nErrorBufVect (int lev) const noexcept { return n_error_buf[lev]; }
 
    [[nodiscard]] Real gridEff () const noexcept { return grid_eff; }
 
    [[nodiscard]] int nProper () const noexcept { return n_proper; }
 
    [[nodiscard]] const IntVect& blockingFactor (int lev) const noexcept { return blocking_factor[lev]; }
 
    [[nodiscard]] const IntVect& maxGridSize (int lev) const noexcept { return max_grid_size[lev]; }
 
    [[nodiscard]] bool LevelDefined (int lev) const noexcept;
 
    [[nodiscard]] bool useFixedCoarseGrids () const noexcept { return use_fixed_coarse_grids; }
 
    [[nodiscard]] int useFixedUpToLevel () const noexcept { return use_fixed_upto_level; }
 
    void ChopGrids (int lev, BoxArray& ba, int target_size) const;
 
    [[nodiscard]] BoxArray MakeBaseGrids () const;
 
    void MakeNewGrids (int lbase, Real time, int& new_finest, Vector<BoxArray>& new_grids);
 
    void MakeNewGrids (Real time = 0.0);
 
    virtual void MakeNewLevelFromScratch (int lev, Real time, const BoxArray& ba, const DistributionMapping& dm) {
        amrex::ignore_unused(lev, time, ba, dm);
    }
 
    virtual void ErrorEst (int lev, TagBoxArray& tags, Real time, int ngrow) {
        amrex::ignore_unused(lev, tags, time, ngrow);
    }
 
    virtual void ManualTagsPlacement (int lev, TagBoxArray& tags, const Vector<IntVect>& bf_lev) {
        amrex::ignore_unused(lev, tags, bf_lev);
    }
 
    virtual void PostProcessBaseGrids(BoxArray& box_array) const { amrex::ignore_unused(box_array); }
 
    [[nodiscard]] virtual BoxArray GetAreaNotToTag (int lev) { (void)lev; return BoxArray(); }
 
    [[nodiscard]] Long CountCells (int lev) const noexcept;
 
    [[nodiscard]] virtual DistributionMapping MakeDistributionMap (int lev, BoxArray const& ba);
 
protected:
 
    int finest_level;    
    Vector<Geometry>            geom;
    Vector<DistributionMapping> dmap;
    Vector<BoxArray>            grids;
 
#ifdef AMREX_USE_BITTREE
    bool use_bittree = false;
    std::unique_ptr<bittree::BittreeAmr> btmesh;
#endif
 
    unsigned int num_setdm = 0;
    unsigned int num_setba = 0;
 
    void checkInput();
 
    void SetIterateToFalse () noexcept { iterate_on_new_grids = false; }
 
    void SetUseNewChop () noexcept { use_new_chop = true; }
 
private:
    void InitAmrMesh (int max_level_in, const Vector<int>& n_cell_in,
                      Vector<IntVect> refrat = Vector<IntVect>(),
                      const RealBox* rb = nullptr, int coord = -1,
                      const int* is_per = nullptr);
 
    static void ProjPeriodic (BoxList& blout, const Box& domain,
                              Array<int,AMREX_SPACEDIM> const& is_per);
};
 
std::ostream& operator<< (std::ostream& os, AmrMesh const& amr_mesh);
 
}
 
#endif