AMReX_StateDescriptor.H

Go to the documentation of this file.

 
#ifndef AMREX_StateDescriptor_H_
#define AMREX_StateDescriptor_H_
#include <AMReX_Config.H>
 
#include <AMReX_Array.H>
#include <AMReX_Vector.H>
#include <AMReX_REAL.H>
#include <AMReX_Box.H>
#include <AMReX_PhysBCFunct.H>
#include <AMReX_Interpolater.H>
#include <AMReX_MFInterpolater.H>
#ifdef AMREX_USE_EB
#include <AMReX_EBInterpolater.H>
#include <AMReX_EBMFInterpolater.H>
#endif
 
#include <utility>
#include <memory>
 
namespace amrex {
 
    using BndryFuncFabDefault = std::function<void(Box const& bx, FArrayBox& data,
                                                   int dcomp, int numcomp,
                                                   Geometry const& geom, Real time,
                                                   const Vector<BCRec>& bcr, int bcomp,
                                                   int scomp)>;
 
class StateDescriptor
{
    friend class DescriptorList;
 
public:
 
    enum TimeCenter { Point = 0 , Interval };
 
    class BndryFunc
    {
    public:
 
        BndryFunc () noexcept = default;
 
        BndryFunc (BndryFuncDefault inFunc) noexcept : m_func(inFunc) {}
 
        BndryFunc (BndryFunc3DDefault inFunc) noexcept : m_func3D(inFunc) {}
 
        BndryFunc (BndryFuncFabDefault inFunc) noexcept : m_funcfab(std::move(inFunc)) {}
 
        BndryFunc (BndryFuncDefault inFunc,BndryFuncDefault gFunc) noexcept
            : m_func(inFunc), m_gfunc(gFunc) {}
 
        BndryFunc (BndryFunc3DDefault inFunc,BndryFunc3DDefault gFunc) noexcept
            : m_func3D(inFunc), m_gfunc3D(gFunc) {}
 
        void operator () (Real* data, const int* lo, const int* hi,
                          const int* dom_lo, const int* dom_hi,
                          const Real* dx, const Real* grd_lo,
                          const Real* time, const int* bc) const;
 
        void operator () (Real* data, const int* lo, const int* hi,
                          const int* dom_lo, const int* dom_hi,
                          const Real* dx, const Real* grd_lo,
                          const Real* time, const int* bc, int ng) const;
 
        void operator () (Box const& bx, FArrayBox& data,
                          int dcomp, int numcomp,
                          Geometry const& geom, Real time,
                          const Vector<BCRec>& bcr, int bcomp,
                          int scomp) const;
 
        [[nodiscard]] bool RunOnGPU () const noexcept { return m_run_on_gpu; }
 
        void setRunOnGPU (bool b) noexcept { m_run_on_gpu = b; }
 
        [[nodiscard]] bool hasFabVersion () const noexcept { return m_funcfab != nullptr; }
 
    private:
 
        BndryFuncDefault   m_func = nullptr;
        BndryFunc3DDefault m_func3D = nullptr;
        BndryFuncDefault   m_gfunc = nullptr;
        BndryFunc3DDefault m_gfunc3D = nullptr;
        BndryFuncFabDefault m_funcfab = nullptr;
        bool m_run_on_gpu = false;
    };
 
    StateDescriptor () noexcept {} // NOLINT /* = default does not work with old clang */
 
    StateDescriptor (IndexType     btyp,
                     TimeCenter    ttyp,
                     int           ident,
                     int           nextra,
                     int           num_comp,
                     InterpBase*   interp,
                     bool          extrap = false,
                     bool          store_in_checkpoint = true);
 
    void define (IndexType     btyp,
                 TimeCenter    ttyp,
                 int           ident,
                 int           nextra,
                 int           num_comp,
                 InterpBase*   interp,
                 bool          extrap = false,
                 bool          store_in_checkpoint = true);
 
    void setComponent (int                comp,
                       const std::string& nm,
                       const BCRec&       bc,
                       const BndryFunc&   func,
                       InterpBase*        interp = nullptr,
                       int                max_map_start_comp = -1,
                       int                min_map_end_comp   = -1);
 
    void setComponent (int                comp,
                       const std::string& nm,
                       const BCRec&       bc,
                       const BndryFunc&   func,
                       InterpBase*        interp,
                       bool               a_primary,
                       int                groupsize);
 
    void resetComponentBCs (int              comp,
                            const BCRec&     bcr,
                            const BndryFunc& func);
 
    void setUpMaps (int&                use_default_map,
                    const InterpBase*   default_map,
                    int                 start_comp,
                    int                 num_comp,
                    InterpBase**&       maps,
                    int&                nmaps,
                    int*&               map_start_comp,
                    int*&               map_num_comp,
                    int*&               max_start_comp,
                    int*&               min_end_comp) const;
 
    static void cleanUpMaps (InterpBase**&   maps,
                      int*&           map_start_comp,
                      int*&           map_num_comp,
                      int*&           max_start_comp,
                      int*&           min_end_comp) ;
 
    void dumpNames (std::ostream& os,
                    int           start_comp,
                    int           num_comp) const;
 
    [[nodiscard]] IndexType getType () const noexcept;
 
    [[nodiscard]] StateDescriptor::TimeCenter timeType () const noexcept;
 
    [[nodiscard]] int nComp () const noexcept;
 
    [[nodiscard]] int nExtra () const noexcept;
 
    [[nodiscard]] InterpBase* interp () const noexcept;
 
    [[nodiscard]] InterpBase* interp (int i) const noexcept;
 
    [[nodiscard]] const std::string& name (int i) const noexcept;
 
    [[nodiscard]] const BCRec& getBC (int i) const noexcept;
 
    [[nodiscard]] const Vector<BCRec>& getBCs () const noexcept;
 
    [[nodiscard]] const BndryFunc& bndryFill (int i) const noexcept;
 
    [[nodiscard]] int inRange (int sc, int nc) const noexcept;
 
    [[nodiscard]] bool identicalInterps (int scomp, int ncomp) const noexcept;
    //
    // Returns contiguous ranges of comps with identical interpolaters.
    //
    [[nodiscard]] std::vector< std::pair<int,int> > sameInterps (int scomp, int ncomp) const;
 
    [[nodiscard]] bool extrap () const noexcept;
 
    [[nodiscard]] bool store_in_checkpoint () const noexcept;
 
    [[nodiscard]] bool primary (int i) const noexcept { return m_primary[i]; }
 
    [[nodiscard]] int groupsize (int i) const noexcept { return m_groupsize[i]; }
 
 
    [[nodiscard]] bool RunOnGPU () const noexcept { return bc_func[0]->RunOnGPU(); }
 
    [[nodiscard]] bool hasBndryFuncFab () const noexcept { return bc_func[0]->hasFabVersion(); }
 
    static void setBndryFuncThreadSafety (int ext_dir_safe) noexcept {
        bf_ext_dir_threadsafe = ext_dir_safe;
    }
 
private:
 
    IndexType           type;            
    TimeCenter          t_type{Point};   
    int                 id{-1};          
    int                 ncomp{0};        
    int                 ngrow{0};        
    InterpBase*         mapper{nullptr}; 
    bool                m_extrap{false}; 
    bool                m_store_in_checkpoint{true}; 
    Vector<std::string> names;         
    Vector<BCRec>       bc;            
    Vector<std::unique_ptr<BndryFunc> >  bc_func; 
    Vector<int>         m_primary;     
    Vector<int>         m_groupsize;   
 
    Vector<InterpBase*> mapper_comp;
 
    Vector<int> max_map_start_comp;
    Vector<int> min_map_end_comp;
 
    static int bf_ext_dir_threadsafe;
 
    static bool bf_thread_safety (const int* lo,const int* hi,
                                  const int* dom_lo, const int* dom_hi,
                                  const int* bc, int ng);
};
 
class DescriptorList
{
public:
 
    void clear ();
 
    [[nodiscard]] int size () const noexcept;
 
    void addDescriptor (int                         indx,
                        IndexType                   typ,
                        StateDescriptor::TimeCenter ttyp,
                        int                         nextra,
                        int                         num_comp,
                        InterpBase*                 interp,
                        bool                        extrap = false,
                        bool                        store_in_checkpoint = true);
 
    void resetComponentBCs (int                               indx,
                            int                               comp,
                            const BCRec&                      bc,
                            const StateDescriptor::BndryFunc& func);
 
    void setComponent (int                               indx,
                       int                               comp,
                       const std::string&                nm,
                       const BCRec&                      bc,
                       const StateDescriptor::BndryFunc& func,
                       InterpBase*                       interp = nullptr,
                       int                               max_map_start_comp = -1,
                       int                               min_map_end_comp   = -1);
 
    void setComponent (int                               indx,
                       int                               comp,
                       const Vector<std::string>&         nm,
                       const Vector<BCRec>&               bc,
                       const StateDescriptor::BndryFunc& func,
                       InterpBase*                       interp = nullptr);
    const StateDescriptor& operator[] (int k) const noexcept;
 
private:
 
    Vector<std::unique_ptr<StateDescriptor> > desc;
};
 
}
 
#endif /*_StateDescriptor_H_*/