AMReX_Derive.H

Go to the documentation of this file.

#ifndef AMREX_Derive_H_
#define AMREX_Derive_H_
#include <AMReX_Config.H>
 
#include <AMReX_ArrayLim.H>
#include <AMReX_REAL.H>
#include <AMReX_Box.H>
#include <AMReX_Interpolater.H>
#include <AMReX_MultiFab.H>
 
#include <list>
#include <string>
 
namespace amrex {
 
extern "C"
{
 
    using DeriveFunc = void (*)(amrex::Real* data, AMREX_ARLIM_P(dlo), AMREX_ARLIM_P(dhi),
                                const int* nvar, const amrex::Real* compdat,
                                AMREX_ARLIM_P(compdat_lo), AMREX_ARLIM_P(compdat_hi),
                                const int* ncomp,
                                const int* lo, const int* hi,
                                const int* domain_lo, const int* domain_hi,
                                const amrex::Real* delta, const amrex::Real* xlo,
                                const amrex::Real* time, const amrex::Real* dt,
                                const int* bcrec,
                                const int* level, const int* grid_no) ;
 
    using DeriveFunc3D = void (*)(amrex::Real* data, const int* dlo, const int* dhi, const int* nvar,
                                  const amrex::Real* compdat, const int* clo, const int* chi, const int* ncomp,
                                  const int* lo, const int* hi,
                                  const int* domain_lo, const int* domain_hi,
                                  const amrex::Real* delta, const amrex::Real* xlo,
                                  const amrex::Real* time, const amrex::Real* dt,
                                  const int* bcrec,
                                  const int* level, const int* grid_no) ;
}
 
using DeriveFuncFab = std::function<void(const amrex::Box& bx, amrex::FArrayBox& derfab, int dcomp, int ncomp,
                                         const amrex::FArrayBox& datafab, const amrex::Geometry& geomdata,
                                         amrex::Real time, const int* bcrec, int level)>;
 
using DeriveFuncMF = std::function<void(amrex::MultiFab& der_mf, int dcomp, int ncomp,
                                        const amrex::MultiFab& data_mf, const amrex::Geometry& geomdata,
                                        amrex::Real time, const int* bcrec, int level)>;
 
class DescriptorList;
 
 
class DeriveRec
{
   friend class DeriveList;
 
public:
 
    using DeriveBoxMap = std::function<Box(const Box&)>;
 
    static Box TheSameBox (const Box& box) noexcept;
 
    static Box GrowBoxByOne (const Box& box) noexcept;
 
    ~DeriveRec ();
 
    DeriveRec (DeriveRec const&) = delete;
    DeriveRec (DeriveRec &&) = delete;
    DeriveRec& operator= (DeriveRec const&) = delete;
    DeriveRec& operator= (DeriveRec &&) = delete;
 
    [[nodiscard]] const std::string& name () const noexcept;
 
    [[nodiscard]] const std::string& variableName (int comp) const noexcept;
 
    [[nodiscard]] IndexType deriveType () const noexcept;
 
    [[nodiscard]] DeriveFunc    derFunc    () const noexcept;
    [[nodiscard]] DeriveFunc3D  derFunc3D  () const noexcept;
    [[nodiscard]] DeriveFuncFab derFuncFab () const noexcept;
    [[nodiscard]] DeriveFuncMF  derFuncMF () const noexcept;
 
    [[nodiscard]] DeriveBoxMap boxMap () const noexcept;
 
    [[nodiscard]] Interpolater* interp () const noexcept;
 
    [[nodiscard]] int numDerive () const noexcept;
 
    [[nodiscard]] int numRange () const noexcept;
 
    [[nodiscard]] int numState () const noexcept;
 
    [[nodiscard]] const int* getBC () const noexcept;
    [[nodiscard]] const int* getBC3D () const noexcept;
 
    void getRange (int  k,
                   int& state_indx,
                   int& src_comp,
                   int& num_comp) const;
 
    DeriveRec (std::string    name,
               IndexType      result_type,
               int            nvar_derive,
               DeriveFunc     der_func,
               DeriveBoxMap   box_map,
               Interpolater*  interp = &pc_interp);
 
    DeriveRec (std::string    name,
               IndexType      result_type,
               int            nvar_derive,
               DeriveFunc3D   der_func_3d,
               DeriveBoxMap   box_map,
               Interpolater*  interp = &pc_interp);
 
    DeriveRec (std::string    name,
               IndexType      result_type,
               int            nvar_derive,
               DeriveFuncFab  der_func_fab,
               DeriveBoxMap   box_map,
               Interpolater*  interp = &pc_interp);
 
    DeriveRec (std::string    name,
               IndexType      result_type,
               int            nvar_derive,
               DeriveFuncMF   der_func_mf,
               DeriveBoxMap   box_map,
               Interpolater*  interp = &pc_interp);
 
 
    DeriveRec (std::string    name,
               IndexType      result_type,
               int            nvar_derive,
               DeriveRec::DeriveBoxMap box_map);
 
    DeriveRec (std::string         name,
               IndexType           result_type,
               int                 nvar_derive,
               Vector<std::string> const& var_names,
               DeriveFunc          der_func,
               DeriveBoxMap        box_map,
               Interpolater*       interp = &pc_interp);
 
    DeriveRec (std::string         name,
               IndexType           result_type,
               int                 nvar_derive,
               Vector<std::string> const& var_names,
               DeriveFunc3D        der_func_3d,
               DeriveBoxMap        box_map,
               Interpolater*       interp = &pc_interp);
 
    DeriveRec (std::string         name,
               IndexType           result_type,
               int                 nvar_derive,
               Vector<std::string> const& var_names,
               DeriveFuncFab       der_func_fab,
               DeriveBoxMap        box_map,
               Interpolater*       interp = &pc_interp);
 
    DeriveRec (std::string         name,
               IndexType           result_type,
               int                 nvar_derive,
               Vector<std::string> const& var_names,
               DeriveFuncMF        der_func_mf,
               DeriveBoxMap        box_map,
               Interpolater*       interp = &pc_interp);
 
    void addRange (const DescriptorList& d_list,
                   int                   state_indx,
                   int                   src_comp,
                   int                   num_comp);
 
    void buildBC (const DescriptorList& d_list);
    void buildBC3D (const DescriptorList& d_list);
 
    struct StateRange
    {
        int         typ;
        int         sc;
        int         nc;
        StateRange* next;
    };
 
private:
 
    std::string derive_name;
 
    Vector<std::string> variable_names;
 
    IndexType der_type;
 
    int n_derive = 0;
 
    DeriveFunc    func = nullptr;
    DeriveFunc3D  func_3d = nullptr;
    DeriveFuncFab func_fab = nullptr;
    DeriveFuncMF  func_mf = nullptr;
 
    Interpolater* mapper = nullptr;
 
    DeriveBoxMap bx_map = nullptr;
 
    int n_state = 0;
 
    int nsr = 0;
 
    StateRange* rng = nullptr;
 
    int* bcr = nullptr;
    int* bcr3D = nullptr;
};
 
 
class DeriveList
{
public:
 
    DeriveList () = default;
 
    ~DeriveList () = default;
    DeriveList (const DeriveList&) = delete;
    DeriveList (DeriveList &&) = delete;
    DeriveList& operator= (const DeriveList&) = delete;
    DeriveList& operator= (DeriveList &&) = delete;
 
    [[nodiscard]] bool canDerive (const std::string& name) const;
 
    [[nodiscard]] const DeriveRec* get (const std::string& name) const;
 
    void add (const std::string&      name,
              IndexType               result_type,
              int                     nvar_derive,
              DeriveFunc              der_func,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               result_type,
              int                     nvar_derive,
              DeriveFunc3D            der_func_3d,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               result_type,
              int                     nvar_derive,
              const DeriveFuncFab&           der_func_fab,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               result_type,
              int                     nvar_derive,
              const DeriveFuncMF&           der_func_mf,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               result_type,
              int                     nvar_derive,
              const DeriveRec::DeriveBoxMap& box_map = &DeriveRec::TheSameBox );
 
    void add (const std::string&      name,
              IndexType               res_typ,
              int                     nvar_derive,
              Vector<std::string> const&    vars,
              DeriveFunc              der_func,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               res_typ,
              int                     nvar_derive,
              Vector<std::string> const&    vars,
              DeriveFunc3D            der_func_3d,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               res_typ,
              int                     nvar_derive,
              Vector<std::string> const&    vars,
              const DeriveFuncFab&           der_func_fab,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void add (const std::string&      name,
              IndexType               res_typ,
              int                     nvar_derive,
              Vector<std::string> const&    vars,
              const DeriveFuncMF&           der_func_mf,
              const DeriveRec::DeriveBoxMap& bx_map,
              Interpolater*           interp = &pc_interp);
 
    void addComponent (const std::string&    name,
                       const DescriptorList& d_list,
                       int                   state_indx,
                       int                   s_comp,
                       int                   n_comp);
 
    [[nodiscard]] std::list<DeriveRec>& dlist ();
 
    void clear () { lst.clear(); }
 
private:
 
    std::list<DeriveRec> lst;
};
 
}
 
#endif /*_Derive_H_*/