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 "src/incflo_enums.H"
#include "src/core/FieldDescTypes.H"
#include "src/core/ViewField.H"
 
namespace kynema_sgf {
 
class Field;
class FieldRepo;
class FieldFillPatchOpsBase;
class FieldBCIface;
class SimTime;

struct FieldInfo
{
    static constexpr int max_field_states = 5;
 
    FieldInfo(
        std::string basename, int ncomp, int ngrow, int nstates, FieldLoc floc);
 
    ~FieldInfo();

    bool bc_initialized();

    void copy_bc_to_device();

    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<InflowValueSource, AMREX_SPACEDIM * 2>
        m_inflow_value_source{};
    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;

    amrex::Vector<std::unique_ptr<FieldFillPatchOpsBase>> m_fillpatch_ops;

    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();

    [[nodiscard]] const std::string& name() const { return m_name; }

    [[nodiscard]] const std::string& base_name() const
    {
        return m_info->m_basename;
    }

    [[nodiscard]] unsigned id() const { return m_id; }

    [[nodiscard]] int num_comp() const { return m_info->m_ncomp; }

    [[nodiscard]] const amrex::IntVect& num_grow() const
    {
        return m_info->m_ngrow;
    }

    [[nodiscard]] int num_time_states() const { return m_info->m_nstates; }

    [[nodiscard]] 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;
    }

    [[nodiscard]] FieldLoc field_location() const { return m_info->m_floc; }

    [[nodiscard]] FieldState field_state() const { return m_state; }

    [[nodiscard]] FieldRepo& repo() const { return m_repo; }
 
    bool& fillpatch_on_regrid() { return m_fillpatch_on_regrid; }
    [[nodiscard]] bool fillpatch_on_regrid() const
    {
        return m_fillpatch_on_regrid;
    }

    [[nodiscard]] bool query_state(const FieldState fstate) const
    {
        const int fid = static_cast<int>(fstate);
        return (m_info->m_states[fid] != nullptr);
    }
 
    [[nodiscard]] 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;
    }
 
    auto& inflow_value_source() { return m_info->m_inflow_value_source; }
    [[nodiscard]] const auto& inflow_value_source() const
    {
        return m_info->m_inflow_value_source;
    }

    [[nodiscard]] amrex::Vector<amrex::BCRec>& bcrec() const
    {
        return m_info->m_bcrec;
    }
 
    [[nodiscard]] const amrex::GpuArray<const amrex::Real*, AMREX_SPACEDIM * 2>&
    bc_values_device() const
    {
        return m_info->m_bc_values_d;
    }
 
    [[nodiscard]] const amrex::Gpu::DeviceVector<amrex::BCRec>&
    bcrec_device() const
    {
        return m_info->m_bcrec_d;
    }

    void copy_bc_to_device() { m_info->copy_bc_to_device(); }

    [[nodiscard]] bool bc_initialized() const
    {
        return m_info->m_bc_copied_to_device;
    }

    [[nodiscard]] bool has_fillpatch_op() const
    {
        return !m_info->m_fillpatch_ops.empty();
    }

    void set_default_fillpatch_bc(
        const SimTime& time,
        amrex::BCType::mathematicalBndryTypes bctype = amrex::BCType::hoextrap);

    void to_uniform_space();

    void to_stretched_space();

    Field& state(FieldState fstate);
    [[nodiscard]] const Field& state(FieldState fstate) const;

    amrex::MultiFab& operator()(int lev);
    const amrex::MultiFab& operator()(int lev) const;

    amrex::Vector<amrex::MultiFab*> vec_ptrs();

    [[nodiscard]] amrex::Vector<const amrex::MultiFab*> vec_const_ptrs() const;

    void advance_states();

    void copy_state(FieldState to_state, FieldState from_state);

    Field& create_state(FieldState fstate);
 
    // NOTE: We break naming rules for methods here to provide 1-1 mapping with
    // the underlying MultiFab method names.

    void setVal(amrex::Real value);

    void
    setVal(amrex::Real value, int start_comp, int num_comp = 1, int nghost = 0);

    void setVal(const amrex::Vector<amrex::Real>& values, int nghost = 0);

    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)
    {
        if (m_info->m_fillpatch_ops.empty()) {
            m_info->m_fillpatch_ops.emplace_back(
                new T(*this, std::forward<Args>(args)...));
        } else if (m_info->m_fillpatch_ops.size() == 1) {
            m_info->m_fillpatch_ops[0].reset(
                new T(*this, std::forward<Args>(args)...));
        } else {
            amrex::Abort(
                "register_fill_patch_op: More than one fillpatch op already "
                "registered. register_fill_patch_op cannot be called after "
                "add_fill_patch_op");
        }
    }
 
    template <typename T, class... Args>
    void add_fill_patch_op(Args&&... args)
    {
        m_info->m_fillpatch_ops.emplace_back(
            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(amrex::Real time);
    void fillpatch(amrex::Real time, amrex::IntVect ng);
    void fillpatch_sibling_fields(
        amrex::Real time,
        amrex::IntVect ng,
        amrex::Array<Field*, AMREX_SPACEDIM>& fields) const;
 
    void fillphysbc(amrex::Real time);
    void fillphysbc(amrex::Real time, amrex::IntVect ng);
 
    void fillphysbc_type(
        amrex::Real time, amrex::BCType::mathematicalBndryTypes bctype);
 
    void apply_bc_funcs(FieldState rho_state);
 
    void fillpatch(
        int lev,
        amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost);
 
    void fillpatch_from_coarse(
        int lev,
        amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost);
 
    void fillphysbc(
        int lev,
        amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost);
 
    void set_inflow(
        int lev,
        amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost);
 
    void set_inflow_sibling_fields(
        int lev,
        amrex::Real time,
        amrex::Array<amrex::MultiFab*, AMREX_SPACEDIM> mfabs);
 
    void fillpatch(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost)
    {
        fillpatch(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    void fillpatch_from_coarse(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost)
    {
        fillpatch_from_coarse(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    void fillphysbc(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost)
    {
        fillphysbc(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    void set_inflow(
        const int lev,
        const amrex::Real time,
        amrex::MultiFab& mfab,
        const int nghost)
    {
        set_inflow(lev, time, mfab, amrex::IntVect(nghost));
    }
 
    bool& in_uniform_space() { return m_mesh_mapped; }
    [[nodiscard]] bool in_uniform_space() const { return m_mesh_mapped; }

    [[nodiscard]] bool has_inout_bndry() const;

    void fill_inout_outflow(
        int lev,
        amrex::Real time,
        amrex::MultiFab& mfab,
        const amrex::IntVect& nghost);
 
protected:
    Field(
        FieldRepo& repo,
        std::string name,
        std::shared_ptr<FieldInfo> finfo,
        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};
};
 
} // namespace kynema_sgf
 
#endif /* FIELD_H */