AMReX_StateData.H

Go to the documentation of this file.

 
#ifndef AMREX_StateData_H_
#define AMREX_StateData_H_
#include <AMReX_Config.H>
 
#include <AMReX_Box.H>
#include <AMReX_BoxArray.H>
#include <AMReX_MultiFab.H>
#include <AMReX_MFCopyDescriptor.H>
#include <AMReX_BCRec.H>
#include <AMReX_Array.H>
#include <AMReX_Vector.H>
#include <AMReX_VisMF.H>
#include <AMReX_DistributionMapping.H>
#include <AMReX_PhysBCFunct.H>
#include <AMReX_Geometry.H>
#include <AMReX_RealBox.H>
#include <AMReX_StateDescriptor.H>
 
#include <memory>
 
namespace amrex {
 
class StateDataPhysBCFunct;
 
 
class StateData
{
    friend class StateDataPhysBCFunct;
 
public:
 
    StateData ();
 
    StateData (const Box&             p_domain,
               const BoxArray&        grds,
               const DistributionMapping& dm,
               const StateDescriptor* d,
               Real                   cur_time,
               Real                   dt,
               const FabFactory<FArrayBox>& factory);
 
    ~StateData ();
 
    StateData (StateData&& rhs) noexcept;
    StateData& operator= (StateData const& rhs);
 
    StateData (StateData const& rhs) = delete;
    StateData& operator= (StateData && rhs) = delete;
 
    void define (const Box&             p_domain,
                 const BoxArray&        grds,
                 const DistributionMapping& dm,
                 const StateDescriptor& d,
                 Real                   cur_time,
                 Real                   dt,
                 const FabFactory<FArrayBox>& factory);
 
    void copyOld (const StateData& state);
 
    void copyNew (const StateData& state);
 
    void allocOldData ();
 
    void removeOldData () { old_data.reset(); }
 
    void reset ();
 
    void swapTimeLevels (Real dt);
 
    void replaceOldData ( MultiFab&& mf );
 
    void replaceOldData ( StateData& s );
 
    void replaceNewData ( MultiFab&& mf );
 
    void replaceNewData ( StateData& s );
 
 
    void setTimeLevel (Real time,
                       Real dt_old,
                       Real dt_new);
 
    void setOldTimeLevel (Real time);
 
    void setNewTimeLevel (Real time);
 
    void syncNewTimeLevel (Real time);
 
    void RegisterData (MultiFabCopyDescriptor& multiFabCopyDesc,
                       Vector<MultiFabId>&      mfid);
 
    void InterpAddBox (MultiFabCopyDescriptor& multiFabCopyDesc,
                       Vector<MultiFabId>&      mfid,
                       BoxList*                returnedUnfillableBoxes,
                       Vector<FillBoxId>&       returnedFillBoxIds,
                       const Box&              subbox,
                       Real                    time,
                       int                     src_comp,
                       int                     dest_comp,
                       int                     num_comp,
                       bool                    extrap = false);
 
    void InterpFillFab (MultiFabCopyDescriptor&  fabCopyDesc,
                        const Vector<MultiFabId>& mfid,
                        const Vector<FillBoxId>&  fillBoxIds,
                        FArrayBox&               dest,
                        Real                     time,
                        int                      src_comp,
                        int                      dest_comp,
                        int                      num_comp,
                        bool                     extrap = false);
 
 
    void FillBoundary (FArrayBox&     dest,
                       Real           time,
                       const Real*    dx,
                       const RealBox& prob_domain,
                       int            dest_comp,
                       int            src_comp,
                       int            num_comp = 1);
 
    void FillBoundary (Box const&      bx,
                       FArrayBox&      dest,
                       Real            time,
                       Geometry const& geom,
                       int             dest_comp,
                       int             src_comp,
                       int             num_comp);
 
    void checkPoint (const std::string& name,
                     const std::string& fullpathname,
                     std::ostream&      os,
                     VisMF::How         how,
                     bool               dump_old = true);
 
    void restart (std::istream&          is,
                  const Box&             p_domain,
                  const BoxArray&        grds,
                  const DistributionMapping& dm,
                  const FabFactory<FArrayBox>& factory,
                  const StateDescriptor& d,
                  const std::string&     chkfile);
 
    void restart (const StateDescriptor& d,
                  const StateData& rhs);
 
    const StateDescriptor* descriptor () const noexcept { return desc; }
 
    const Box& getDomain () const noexcept { return domain; }
 
    const BoxArray& boxArray () const noexcept { return grids; }
 
    void setBoxArray (BoxArray const& a_grids) noexcept { grids = a_grids; }
 
    const DistributionMapping& DistributionMap () const noexcept { return dmap; }
 
    void setDistributionMap ( DistributionMapping& new_dmap ) noexcept { dmap = new_dmap; }
 
    const FabFactory<FArrayBox>& Factory () const noexcept { return *m_factory; }
 
    void setFactory (FabFactory<FArrayBox> const& a_factory) {
        m_factory.reset(a_factory.clone());
    }
 
    Real curTime () const noexcept {
        return (desc->timeType() == StateDescriptor::Point) ?
            new_time.stop : 0.5_rt*(new_time.start + new_time.stop);
    }
 
    Real prevTime () const noexcept {
        return (desc->timeType() == StateDescriptor::Point) ?
            old_time.stop : 0.5_rt*(old_time.start + old_time.stop);
    }
 
    MultiFab& newData () noexcept { BL_ASSERT(new_data != nullptr); return *new_data; }
 
    const MultiFab& newData () const noexcept { BL_ASSERT(new_data != nullptr); return *new_data; }
 
    MultiFab& oldData () noexcept { BL_ASSERT(old_data != nullptr); return *old_data; }
 
    const MultiFab& oldData () const noexcept { BL_ASSERT(old_data != nullptr); return *old_data; }
 
    FArrayBox& newGrid (int i) noexcept { BL_ASSERT(new_data != nullptr); return (*new_data)[i]; }
 
    FArrayBox& oldGrid (int i) noexcept { BL_ASSERT(old_data != nullptr); return (*old_data)[i]; }
 
    BCRec getBC (int comp, int i) const noexcept;
 
    void printTimeInterval (std::ostream& os) const;
 
    bool hasOldData () const noexcept { return old_data != nullptr; }
 
    bool hasNewData () const noexcept { return new_data != nullptr; }
 
    void getData (Vector<MultiFab*>& data,
                  Vector<Real>& datatime,
                  Real time) const;
 
    Arena* getArena () const noexcept { return arena; }
 
    void setArena (Arena* ar) noexcept { arena = ar; }
 
    static const Vector<std::string> &FabArrayHeaderNames() { return fabArrayHeaderNames; }
    static void ClearFabArrayHeaderNames() { fabArrayHeaderNames.clear(); }
 
    static void SetFAHeaderMapPtr(std::map<std::string, Vector<char> > *fahmp) { faHeaderMap = fahmp; }
 
 
private:
 
    std::unique_ptr<FabFactory<FArrayBox> > m_factory;
 
    struct TimeInterval
    {
        Real start;
        Real stop;
    };
 
    const StateDescriptor* desc{nullptr};
 
    Box domain;
 
    BoxArray grids;
    //
    DistributionMapping dmap;
 
    TimeInterval new_time;
 
    TimeInterval old_time;
 
    std::unique_ptr<MultiFab> new_data;
 
    std::unique_ptr<MultiFab> old_data;
 
    Arena* arena{nullptr};
 
    static Vector<std::string> fabArrayHeaderNames;
 
    static std::map<std::string, Vector<char> > *faHeaderMap;  // ---- [faheader name, the header]
 
    void restartDoit (std::istream& is, const std::string& chkfile);
};
 
class StateDataPhysBCFunct
{
public:
 
    StateDataPhysBCFunct (StateData& sd, int sc, const Geometry& geom_);
 
    void operator() (MultiFab& mf, int dest_comp, int num_comp, IntVect const& nghost,
                     Real time, int bccomp);
 
    void FillBoundary (MultiFab& mf, int dest_comp, int num_comp, IntVect const& nghost,
                       Real time, int bccomp) {
        this->operator()(mf,dest_comp,num_comp,nghost,time,bccomp); // NOLINT(readability-suspicious-call-argument)
    }
private:
    StateData* statedata;
    int src_comp;
    const Geometry* geom;
 
};
 
}
 
#endif /*_StateData_H_*/