Field.H

Go to the documentation of this file.

#ifndef FIELD_H
#define FIELD_H
 
#include <string>
#include <memory>
#include <unordered_map>
#include <algorithm>
 
#include "AMReX_MultiFab.H"
#include "AMReX_BCRec.H"
#include "AMReX_Gpu.H"
 
#include "amr-wind/incflo_enums.H"
#include "amr-wind/core/FieldDescTypes.H"
#include "amr-wind/core/ViewField.H"
 
namespace amr_wind {
 
class Field;
class FieldRepo;
class FieldFillPatchOpsBase;
class FieldBCIface;
class SimTime;
 
struct FieldInfo
{
    static constexpr int max_field_states = 5;
 
    FieldInfo(
        std::string basename,
        const int ncomp,
        const int ngrow,
        const int nstates,
        const FieldLoc floc);
 
    ~FieldInfo();
 
    bool bc_initialized();
 
    void copy_bc_to_device() noexcept;
 
    std::string m_basename;
 
    int m_ncomp;
 
    amrex::IntVect m_ngrow;
 
    int m_nstates;
 
    FieldLoc m_floc;
 
    amrex::GpuArray<BC, AMREX_SPACEDIM * 2> m_bc_type;
    amrex::Vector<amrex::Vector<amrex::Real>> m_bc_values;
    amrex::GpuArray<const amrex::Real*, AMREX_SPACEDIM * 2> m_bc_values_d;
    amrex::Gpu::DeviceVector<amrex::Real> m_bc_values_dview;
 
    amrex::Vector<amrex::BCRec> m_bcrec;
    amrex::Gpu::DeviceVector<amrex::BCRec> m_bcrec_d;
 
    amrex::Vector<Field*> m_states;
 
    std::unique_ptr<FieldFillPatchOpsBase> m_fillpatch_op;
 
    amrex::Vector<std::unique_ptr<FieldBCIface>> m_bc_func;
 
    bool m_bc_copied_to_device{false};
};
 
class Field
{
public:
    friend class FieldRepo;
 
    Field(const Field&) = delete;
    Field& operator=(const Field&) = delete;
    ~Field();
 
    inline const std::string& name() const { return m_name; }
 
    inline const std::string& base_name() const { return m_info->m_basename; }
 
    inline unsigned id() const { return m_id; }
 
    inline int num_comp() const { return m_info->m_ncomp; }
 
    inline const amrex::IntVect& num_grow() const { return m_info->m_ngrow; }
 
    inline int num_time_states() const { return m_info->m_nstates; }
 
    inline int num_states() const
    {
        int ns = static_cast<int>(std::count_if(
            m_info->m_states.begin(), m_info->m_states.end(),
            [](const Field* ff) { return (ff != nullptr); }));
        AMREX_ASSERT(num_time_states() <= ns);
        return ns;
    }
 
    inline FieldLoc field_location() const { return m_info->m_floc; }
 
    inline FieldState field_state() const { return m_state; }
 
    inline FieldRepo& repo() const { return m_repo; }
 
    inline bool& fillpatch_on_regrid() { return m_fillpatch_on_regrid; }
    inline bool fillpatch_on_regrid() const { return m_fillpatch_on_regrid; }
 
    inline bool query_state(const FieldState fstate) const
    {
        const int fid = static_cast<int>(fstate);
        return (m_info->m_states[fid] != nullptr);
    }
 
    const amrex::GpuArray<BC, AMREX_SPACEDIM * 2>& bc_type() const
    {
        return m_info->m_bc_type;
    }
 
    amrex::GpuArray<BC, AMREX_SPACEDIM * 2>& bc_type()
    {
        return m_info->m_bc_type;
    }
 
    amrex::Vector<amrex::Vector<amrex::Real>>& bc_values()
    {
        return m_info->m_bc_values;
    }
 
    amrex::Vector<amrex::BCRec>& bcrec() const { return m_info->m_bcrec; }
 
    const amrex::GpuArray<const amrex::Real*, AMREX_SPACEDIM * 2>&
    bc_values_device() const
    {
        return m_info->m_bc_values_d;
    }
 
    const amrex::Gpu::DeviceVector<amrex::BCRec>& bcrec_device() const
    {
        return m_info->m_bcrec_d;
    }
 
    inline void copy_bc_to_device() { m_info->copy_bc_to_device(); }
 
    inline bool bc_initialized() const { return m_info->m_bc_copied_to_device; }
 
    inline bool has_fillpatch_op() const
    {
        return static_cast<bool>(m_info->m_fillpatch_op);
    }
 
    void set_default_fillpatch_bc(
        const SimTime& time,
        const amrex::BCType::mathematicalBndryTypes bctype =
            amrex::BCType::hoextrap) noexcept;
 
    void to_uniform_space() noexcept;
 
    void to_stretched_space() noexcept;
 
    Field& state(const FieldState fstate);
    const Field& state(const FieldState fstate) const;
 
    amrex::MultiFab& operator()(int lev) noexcept;
    const amrex::MultiFab& operator()(int lev) const noexcept;
 
    amrex::Vector<amrex::MultiFab*> vec_ptrs() noexcept;
 
    amrex::Vector<const amrex::MultiFab*> vec_const_ptrs() const noexcept;
 
    void advance_states() noexcept;
 
    void copy_state(FieldState to_state, FieldState from_state) noexcept;
 
    Field& create_state(const FieldState fstate) noexcept;
 
    // NOTE: We break naming rules for methods here to provide 1-1 mapping with
    // the underlying MultiFab method names.
 
    void setVal(amrex::Real value) noexcept;
 
    void setVal(
        amrex::Real value,
        int start_comp,
        int num_comp = 1,
        int nghost = 0) noexcept;
 
    void
    setVal(const amrex::Vector<amrex::Real>& values, int nghost = 0) noexcept;
 
    ViewField<Field> subview(const int scomp = 0, const int ncomp = 1)
    {
        return {*this, scomp, ncomp};
    }
 
    template <typename T, class... Args>
    void register_fill_patch_op(Args&&... args)
    {
        m_info->m_fillpatch_op.reset(new T(*this, std::forward<Args>(args)...));
    }
 
    template <typename T, class... Args>
    void register_custom_bc(Args&&... args)
    {
        m_info->m_bc_func.emplace_back(
            new T(*this, std::forward<Args>(args)...));
    }
 
    void fillpatch(const amrex::Real time) noexcept;
    void fillpatch(const amrex::Real time, amrex::IntVect ng) noexcept;
    void fillpatch_sibling_fields(
        const amrex::Real time,
        const amrex::IntVect ng,
        amrex::Array<Field*, AMREX_SPACEDIM>& fields) const noexcept;
 
    void fillphysbc(const amrex::Real time) noexcept;
    void fillphysbc(const amrex::Real time, const amrex::IntVect ng) noexcept;
 
    void apply_bc_funcs(const FieldState rho_state) noexcept;
 
    void fillpatch(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost) noexcept;
 
    void fillpatch_from_coarse(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost) noexcept;
 
    void fillphysbc(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost) noexcept;
 
    void set_inflow(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost) noexcept;
 
    void set_inflow_sibling_fields(
        const int lev,
        const amrex::Real time,
        const amrex::Array<amrex::MultiFab*, AMREX_SPACEDIM> mfabs) noexcept;
 
    inline void fillpatch(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost) noexcept
    {
        fillpatch(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    inline void fillpatch_from_coarse(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost) noexcept
    {
        fillpatch_from_coarse(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    inline void fillphysbc(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost) noexcept
    {
        fillphysbc(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    inline void set_inflow(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost) noexcept
    {
        set_inflow(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    inline bool& in_uniform_space() { return m_mesh_mapped; }
    inline bool in_uniform_space() const { return m_mesh_mapped; }
 
    inline bool has_inout_bndry() const { return m_inout_bndry; }
 
    void set_inout_bndry() { m_inout_bndry = true; }
 
protected:
    Field(
        FieldRepo& repo,
        std::string name,
        std::shared_ptr<FieldInfo> finfo,
        const unsigned fid,
        FieldState state);
 
    FieldRepo& m_repo;
 
    const std::string m_name;
 
    std::shared_ptr<FieldInfo> m_info;
 
    const unsigned m_id;
 
    const FieldState m_state;
 
    bool m_fillpatch_on_regrid{false};
 
    bool m_mesh_mapped{false};
 
    bool m_inout_bndry{false};
};
 
} // namespace amr_wind
 
#endif /* FIELD_H */