AMReX_AmrLevel.H

Go to the documentation of this file.

 
#ifndef AMREX_AmrLevel_H_
#define AMREX_AmrLevel_H_
#include <AMReX_Config.H>
 
#include <AMReX_REAL.H>
#include <AMReX_Geometry.H>
#include <AMReX_MultiFab.H>
#include <AMReX_MultiFabUtil.H>
#include <AMReX_LayoutData.H>
#include <AMReX_Derive.H>
#include <AMReX_BCRec.H>
#include <AMReX_Amr.H>
#include <AMReX_DistributionMapping.H>
#include <AMReX_StateDescriptor.H>
#include <AMReX_StateData.H>
#include <AMReX_VisMF.H>
#include <AMReX_RungeKutta.H>
#include <AMReX_FillPatcher.H>
 
#ifdef AMREX_USE_EB
#include <AMReX_EBSupport.H>
#endif
 
#include <memory>
#include <map>
 
namespace amrex {
 
class TagBox;
class TagBoxArray;
 
class AmrLevel
{
    friend class Amr;
    friend class FillPatchIterator;
    friend class FillPatchIteratorHelper;
 
public:
    enum TimeLevel { AmrOldTime,
                     AmrHalfTime,
                     AmrNewTime,
                     Amr1QtrTime,
                     Amr3QtrTime,
                     AmrOtherTime };
    virtual ~AmrLevel ();
 
    AmrLevel (const AmrLevel&) = delete;
    AmrLevel (AmrLevel&&) = delete;
    AmrLevel& operator= (const AmrLevel&) = delete;
    AmrLevel& operator= (AmrLevel&&) = delete;
 
    void LevelDirectoryNames (const std::string &dir,
                              std::string &LevelDir,
                              std::string &FullPath) const;
    virtual void CreateLevelDirectory (const std::string &dir);
    void SetLevelDirectoryCreated(bool ldc) noexcept { levelDirectoryCreated = ldc; }
    virtual std::string thePlotFileType () const
    {
        static const std::string the_plot_file_type("HyperCLaw-V1.1"); 
        return the_plot_file_type;
    }
    virtual void writePlotFile (const std::string& dir,
                                std::ostream&      os,
                                VisMF::How         how = VisMF::NFiles);
 
    virtual void writePlotFilePre (const std::string& dir,
                                   std::ostream&      os);
 
    virtual void writePlotFilePost (const std::string& dir,
                                    std::ostream&      os);
 
    virtual void writeSmallPlotFile (const std::string& dir,
                                     std::ostream&      os,
                                     VisMF::How         how = VisMF::NFiles)
    {
        (void)dir;
        (void)os;
        (void)how;
    }
    virtual void checkPoint (const std::string& dir,
                             std::ostream&      os,
                             VisMF::How         how = VisMF::NFiles,
                             bool               dump_old = true);
    virtual void checkPointPre (const std::string& dir,
                                std::ostream&      os);
    virtual void checkPointPost (const std::string& dir,
                                 std::ostream&      os);
    virtual void restart (Amr&          papa,
                          std::istream& is,
                          bool          bReadSpecial = false);
 
    virtual void set_state_in_checkpoint (Vector<int>& state_in_checkpoint);
 
    static bool isStateVariable (const std::string& name,
                                int&               state_indx,
                                int&               ncomp);
 
    static void FlushFPICache ();
    virtual void computeInitialDt (int                   finest_level,
                                   int                   sub_cycle,
                                   Vector<int>&           n_cycle,
                                   const Vector<IntVect>& ref_ratio,
                                   Vector<Real>&          dt_level,
                                   Real                  stop_time) = 0;
    virtual void computeNewDt (int                   finest_level,
                               int                   sub_cycle,
                               Vector<int>&           n_cycle,
                               const Vector<IntVect>& ref_ratio,
                               Vector<Real>&          dt_min,
                               Vector<Real>&          dt_level,
                               Real                  stop_time,
                               int                   post_regrid_flag) = 0;
    virtual Real advance (Real time,
                          Real dt,
                          int  iteration,
                          int  ncycle) = 0;
 
    virtual void post_timestep (int iteration);
    virtual void postCoarseTimeStep (Real time);
    virtual void post_restart () {}
    virtual  void post_regrid (int lbase,
                               int new_finest) = 0;
    virtual  void post_init (Real stop_time) = 0;
    virtual  int okToContinue () { return 1; }
    virtual  int okToRegrid ();
    virtual void initData () = 0;
    virtual void setTimeLevel (Real time,
                               Real dt_old,
                               Real dt_new);
    virtual void allocOldData ();
    virtual void removeOldData ();
    virtual void init (AmrLevel &old) = 0;
    virtual void init () = 0;
    void reset ();
    int Level () const noexcept { return level; }
    const BoxArray& boxArray () const noexcept { return grids; }
    const BoxArray& getEdgeBoxArray (int dir) const noexcept;
    const BoxArray& getNodalBoxArray () const noexcept;
    //
    const DistributionMapping& DistributionMap () const noexcept { return dmap; }
    //
    const FabFactory<FArrayBox>& Factory () const noexcept { return *m_factory; }
    //
#ifdef AMREX_USE_EB
    const EBFArrayBoxFactory&
    EBFactory () const noexcept {
        return static_cast<amrex::EBFArrayBoxFactory const&>(*m_factory);
    }
#endif
    //
    int numGrids () const noexcept { return static_cast<int>(grids.size()); }
    int numStates () const noexcept { return static_cast<int>(state.size()); }
    const Box& Domain () const noexcept { return geom.Domain(); }
    int nStep () const noexcept { return parent->levelSteps(level); }
    const Geometry& Geom () const noexcept { return geom; }
    //
    const IntVect& fineRatio () const noexcept { return fine_ratio; }
    Long countCells () const noexcept;
 
    const BoxArray& getAreaNotToTag () noexcept;
    const Box& getAreaToTag () noexcept;
    void constructAreaNotToTag ();
    void setAreaNotToTag (BoxArray& ba) noexcept;
 
    void resetFillPatcher ();
 
    virtual void errorEst (TagBoxArray& tb,
                           int          clearval,
                           int          tagval,
                           Real         time,
                           int          n_error_buf = 0,
                           int          ngrow = 0) = 0;
 
    void FillCoarsePatch (MultiFab& mf,
                          int       dcomp,
                          Real      time,
                          int       state_idx,
                          int       scomp,
                          int       ncomp,
                          int       nghost = 0);
    virtual void setPhysBoundaryValues (FArrayBox& dest,
                                        int        state_indx,
                                        Real       time,
                                        int        dest_comp,
                                        int        src_comp,
                                        int        num_comp);
    virtual std::unique_ptr<MultiFab> derive (const std::string& name,
                                              Real               time,
                                              int                ngrow);
    virtual void derive (const std::string& name,
                         Real               time,
                         MultiFab&          mf,
                         int                dcomp);
    StateData& get_state_data (int state_indx) noexcept { return state[state_indx]; }
    MultiFab& get_old_data (int state_indx) noexcept { return state[state_indx].oldData(); }
    const MultiFab& get_old_data (int state_indx) const noexcept { return state[state_indx].oldData(); }
    MultiFab& get_new_data (int state_indx) noexcept { return state[state_indx].newData(); }
    const MultiFab& get_new_data (int state_indx) const noexcept { return state[state_indx].newData(); }
    static const DescriptorList& get_desc_lst () noexcept { return desc_lst; }
    static DeriveList& get_derive_lst () noexcept;
    int postStepRegrid () const noexcept { return post_step_regrid; }
    void setPostStepRegrid (int new_val) noexcept { post_step_regrid = new_val; }
 
    void UpdateDistributionMaps ( DistributionMapping& dmap );
 
    Vector<int> getBCArray (int State_Type,
                            int gridno,
                            int strt_comp,
                            int ncomp);
    MultiFab& get_data (int  state_indx, Real time) noexcept;
    virtual void set_preferred_boundary_values (MultiFab& S,
                                                int       state_index,
                                                int       scomp,
                                                int       dcomp,
                                                int       ncomp,
                                                Real      time) const;
    virtual void manual_tags_placement (TagBoxArray&    tags,
                                        const Vector<IntVect>& bf_lev);
    virtual void setPlotVariables ();
    virtual void setSmallPlotVariables ();
    virtual Real estimateWork();
 
    virtual int WorkEstType () { return -1; }
 
    TimeLevel which_time (int  state_indx, Real time) const noexcept;
 
    virtual bool checkPointNow ();
 
    virtual bool writePlotNow ();
 
    virtual bool writeSmallPlotNow ();
 
#ifdef AMREX_PARTICLES
    virtual void particle_redistribute (int lbase = 0, bool a_init = false)
    {
        (void)lbase;
        (void)a_init;
    }
#endif
 
    void FillPatcherFill (amrex::MultiFab& mf, int dcomp, int ncomp, int nghost,
                          amrex::Real time, int state_index, int scomp);
 
    static void FillPatch (AmrLevel& amrlevel,
                           MultiFab& leveldata,
                           int       boxGrow,
                           Real      time,
                           int       index,
                           int       scomp,
                           int       ncomp,
                           int       dcomp=0);
 
    static void FillPatchAdd (AmrLevel& amrlevel,
                              MultiFab& leveldata,
                              int       boxGrow,
                              Real      time,
                              int       index,
                              int       scomp,
                              int       ncomp,
                              int       dcomp=0);
 
    template <typename F, typename P = RungeKutta::PostStageNoOp>
    void RK (int order, int state_type, Real time, Real dt, int iteration,
             int ncycle, F&& f, P&& p = RungeKutta::PostStageNoOp());
 
#ifdef AMREX_USE_EB
    static void SetEBMaxGrowCells (int nbasic, int nvolume, int nfull) noexcept {
        m_eb_basic_grow_cells = nbasic;
        m_eb_volume_grow_cells = nvolume;
        m_eb_full_grow_cells = nfull;
    }
    static int            m_eb_basic_grow_cells;
    static int            m_eb_volume_grow_cells;
    static int            m_eb_full_grow_cells;
    static void SetEBSupportLevel (EBSupport ebs) { m_eb_support_level = ebs; }
    static EBSupport      m_eb_support_level;
#endif
 
    static IntVect ProperBlockingFactor (AmrLevel const& amr_level, int boxGrow,
                                         IndexType const& boxType,
                                         StateDescriptor const& desc, int SComp);
 
protected:
    AmrLevel () noexcept {} // NOLINT
 
    AmrLevel (Amr&            papa,
              int             lev,
              const Geometry& level_geom,
              const BoxArray& ba,
              const DistributionMapping& dm,
              Real            time);
 
    void finishConstructor ();
 
    //
    // The Data.
    //
    int                   level{-1};    // AMR level (0 is coarsest).
    Geometry              geom;         // Geom at this level.
    BoxArray              grids;        // Cell-centered locations of grids.
    DistributionMapping   dmap;         // Distribution of grids among processes
    Amr*                  parent{nullptr};// Pointer to parent AMR structure.
    IntVect               crse_ratio;   // Refinement ratio to coarser level.
    IntVect               fine_ratio;   // Refinement ratio to finer level.
    static DeriveList     derive_lst;   // List of derived quantities.
    static DescriptorList desc_lst;     // List of state variables.
    Vector<StateData>     state;        // Array of state data.
 
    BoxArray m_AreaNotToTag; //Area which shouldn't be tagged on this level.
    Box      m_AreaToTag;    //Area which is allowed to be tagged on this level.
 
    int post_step_regrid{0}; // Whether or not to do a regrid after the timestep.
 
    bool levelDirectoryCreated{false}; // for checkpoints and plotfiles
 
    std::unique_ptr<FabFactory<FArrayBox> > m_factory;
 
    Vector<std::unique_ptr<FillPatcher<MultiFab>>> m_fillpatcher;
 
private:
 
    template <std::size_t order>
    void storeRKCoarseData (int state_type, Real time, Real dt,
                            MultiFab const& S_old,
                            Array<MultiFab,order> const& rkk);
 
    void FillRKPatch (int state_index, MultiFab& S, Real time,
                      int stage, int iteration, int ncycle);
 
    mutable BoxArray      edge_grids[AMREX_SPACEDIM];  // face-centered grids
    mutable BoxArray      nodal_grids;              // all nodal grids
};
 
//
// Forward declaration.
//
class FillPatchIteratorHelper;
 
class FillPatchIterator
    :
    public MFIter
{
  public:
 
    friend class AmrLevel;
 
    FillPatchIterator (AmrLevel& amrlevel,
                       MultiFab& leveldata);
 
    FillPatchIterator (AmrLevel& amrlevel,
                       MultiFab& leveldata,
                       int       boxGrow,
                       Real      time,
                       int       idx,
                       int       scomp,
                       int       ncomp);
 
    void Initialize (int  boxGrow,
                     Real time,
                     int  idx,
                     int  scomp,
                     int  ncomp);
 
    FArrayBox& operator() () noexcept { return m_fabs[MFIter::index()]; }
 
    Box UngrownBox () const noexcept { return MFIter::validbox(); }
 
    MultiFab& get_mf() noexcept { return m_fabs; }
 
private:
 
    void FillFromLevel0 (Real time, int idx, int scomp, int dcomp, int ncomp);
    void FillFromTwoLevels (Real time, int idx, int scomp, int dcomp, int ncomp);
 
    //
    // The data.
    //
    AmrLevel*                         m_amrlevel;
    MultiFab*                         m_leveldata;
    std::vector< std::pair<int,int> > m_range;
    MultiFab                          m_fabs;
    int                               m_ncomp;
};
 
class FillPatchIteratorHelper
{
public:
 
    friend class FillPatchIterator;
 
    FillPatchIteratorHelper (AmrLevel& amrlevel,
                             MultiFab& leveldata);
 
    FillPatchIteratorHelper (AmrLevel&     amrlevel,
                             MultiFab&     leveldata,
                             int           boxGrow,
                             Real          time,
                             int           index,
                             int           scomp,
                             int           ncomp,
                             InterpBase*   mapper);
 
    void Initialize (int           boxGrow,
                     Real          time,
                     int           idx,
                     int           scomp,
                     int           ncomp,
                     InterpBase*   mapper);
 
    void fill (FArrayBox& fab, int dcomp, int idx);
 
private:
    //
    // The data.
    //
    AmrLevel*                  m_amrlevel;
    MultiFab*                  m_leveldata;
    MultiFabCopyDescriptor     m_mfcd;
    Vector< Vector<MultiFabId> > m_mfid;     // [level][oldnew]
    Interpolater*              m_map = nullptr;
    std::map<int,Box>          m_ba;
    Real                       m_time = std::numeric_limits<Real>::lowest();
    int                        m_growsize = std::numeric_limits<int>::lowest();
    int                        m_index = -1;
    int                        m_scomp = -1;
    int                        m_ncomp = -1;
    bool                       m_FixUpCorners = false;
 
    std::map< int,Vector< Vector<Box> > >                m_fbox; // [grid][level][validregion]
    std::map< int,Vector< Vector<Box> > >                m_cbox; // [grid][level][fillablesubbox]
    std::map< int,Vector< Vector< Vector<FillBoxId> > > > m_fbid; // [grid][level][fillablesubbox][oldnew]
};
 
template <typename F, typename P>
void AmrLevel::RK (int order, int state_type, Real time, Real dt, int iteration,
                   int ncycle, F&& f, P&& p)
{
    BL_PROFILE("AmrLevel::RK()");
 
    AMREX_ASSERT(AmrLevel::desc_lst[state_type].nExtra() > 0); // Need ghost cells in StateData
 
    MultiFab& S_old = get_old_data(state_type);
    MultiFab& S_new = get_new_data(state_type);
 
    if (order == 2) {
        RungeKutta::RK2(S_old, S_new, time, dt, std::forward<F>(f),
                        [&] (int /*stage*/, MultiFab& mf, Real t) {
                            FillPatcherFill(mf, 0, mf.nComp(), mf.nGrow(), t,
                                            state_type, 0); },
                        std::forward<P>(p));
    } else if (order == 3) {
        RungeKutta::RK3(S_old, S_new, time, dt, std::forward<F>(f),
                        [&] (int stage, MultiFab& mf, Real t) {
                            FillRKPatch(state_type, mf, t, stage, iteration, ncycle);
                        },
                        [&] (Array<MultiFab,3> const& rkk) {
                            if (level < parent->finestLevel()) {
                                storeRKCoarseData(state_type, time, dt, S_old, rkk);
                            }
                        },
                        std::forward<P>(p));
    } else if (order == 4) {
        RungeKutta::RK4(S_old, S_new, time, dt, std::forward<F>(f),
                        [&] (int stage, MultiFab& mf, Real t) {
                            FillRKPatch(state_type, mf, t, stage, iteration, ncycle);
                        },
                        [&] (Array<MultiFab,4> const& rkk) {
                            if (level < parent->finestLevel()) {
                                storeRKCoarseData(state_type, time, dt, S_old, rkk);
                            }
                        },
                        std::forward<P>(p));
    } else {
        amrex::Abort("AmrLevel::RK: order = "+std::to_string(order)+" is not supported");
    }
}
 
template <std::size_t order>
void AmrLevel::storeRKCoarseData (int state_type, Real time, Real dt,
                                  MultiFab const& S_old,
                                  Array<MultiFab,order> const& rkk)
{
    BL_PROFILE("AmrLevel::storeRKCoarseData()");
    if (level == parent->finestLevel()) { return; }
 
    const StateDescriptor& desc = AmrLevel::desc_lst[state_type];
 
    auto& fillpatcher = parent->getLevel(level+1).m_fillpatcher[state_type];
    fillpatcher = std::make_unique<FillPatcher<MultiFab>>
        (parent->boxArray(level+1), parent->DistributionMap(level+1),
         parent->Geom(level+1),
         parent->boxArray(level), parent->DistributionMap(level),
         parent->Geom(level),
         IntVect(desc.nExtra()), desc.nComp(), desc.interp(0));
 
    fillpatcher->storeRKCoarseData(time, dt, S_old, rkk);
}
 
 
}
 
#endif /*_AmrLevel_H_*/