FieldRepo.H

Go to the documentation of this file.

#ifndef FIELDREPO_H
#define FIELDREPO_H
 
#include <string>
#include <unordered_map>
 
#include "amr-wind/core/FieldDescTypes.H"
#include "amr-wind/core/FieldUtils.H"
#include "amr-wind/core/Field.H"
#include "amr-wind/core/IntField.H"
#include "amr-wind/core/ScratchField.H"
#include "amr-wind/core/IntScratchField.H"
 
#include "AMReX_AmrCore.H"
#include "AMReX_MultiFab.H"
#include "AMReX_iMultiFab.H"
 
namespace amr_wind {


struct LevelDataHolder
{
    LevelDataHolder();

    amrex::Vector<amrex::MultiFab> m_mfabs;
    std::unique_ptr<amrex::FabFactory<amrex::FArrayBox>> m_factory;

    amrex::Vector<amrex::iMultiFab> m_int_fabs;
    std::unique_ptr<amrex::FabFactory<amrex::IArrayBox>> m_int_fact;
};

class FieldRepo
{
public:
    friend class Field;
    friend class IntField;
 
    explicit FieldRepo(const amrex::AmrCore& mesh)
        : m_mesh(mesh), m_leveldata(mesh.maxLevel() + 1)
    {}
 
    FieldRepo(const FieldRepo&) = delete;
    FieldRepo& operator=(const FieldRepo&) = delete;
    ~FieldRepo() = default;

    void make_new_level_from_scratch(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm);

    void make_new_level_from_coarse(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm);

    void remake_level(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm);

    void clear_level(int lev);

    Field& declare_field(
        const std::string& name,
        int ncomp = 1,
        int ngrow = 0,
        int nstates = 1,
        FieldLoc floc = FieldLoc::CELL);

    Field& declare_cc_field(
        const std::string& name,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        return declare_field(name, ncomp, ngrow, nstates, FieldLoc::CELL);
    }

    Field& declare_nd_field(
        const std::string& name,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        return declare_field(name, ncomp, ngrow, nstates, FieldLoc::NODE);
    }

    Field& declare_xf_field(
        const std::string& name,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        return declare_field(name, ncomp, ngrow, nstates, FieldLoc::XFACE);
    }

    Field& declare_yf_field(
        const std::string& name,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        return declare_field(name, ncomp, ngrow, nstates, FieldLoc::YFACE);
    }

    Field& declare_zf_field(
        const std::string& name,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        return declare_field(name, ncomp, ngrow, nstates, FieldLoc::ZFACE);
    }

    amrex::Vector<Field*> declare_face_normal_field(
        const amrex::Vector<std::string>& names,
        const int ncomp = 1,
        const int ngrow = 0,
        const int nstates = 1)
    {
        AMREX_ASSERT(names.size() == AMREX_SPACEDIM);
        return {
            &declare_field(names[0], ncomp, ngrow, nstates, FieldLoc::XFACE),
            &declare_field(names[1], ncomp, ngrow, nstates, FieldLoc::YFACE),
            &declare_field(names[2], ncomp, ngrow, nstates, FieldLoc::ZFACE),
        };
    }

    Field& get_field(
        const std::string& name, FieldState fstate = FieldState::New) const;

    Field& get_field(const int field_id) const
    {
        return *m_field_vec.at(field_id);
    }

    Field& get_mesh_mapping_field(FieldLoc floc) const;

    Field& get_mesh_mapping_det_j(FieldLoc floc) const;

    bool field_exists(
        const std::string& name, FieldState fstate = FieldState::New) const;

    IntField& declare_int_field(
        const std::string& name,
        int ncomp = 1,
        int ngrow = 0,
        int nstates = 1,
        FieldLoc floc = FieldLoc::CELL);

    IntField& get_int_field(
        const std::string& name, FieldState fstate = FieldState::New) const;

    IntField& get_int_field(const int field_id) const
    {
        return *m_int_field_vec.at(field_id);
    }

    bool int_field_exists(
        const std::string& name, FieldState fstate = FieldState::New) const;

    std::unique_ptr<ScratchField> create_scratch_field(
        const std::string& name,
        int ncomp = 1,
        int nghost = 0,
        FieldLoc floc = FieldLoc::CELL) const;

    std::unique_ptr<ScratchField> create_scratch_field(
        int ncomp = 1, int nghost = 0, FieldLoc floc = FieldLoc::CELL) const;
 
    std::unique_ptr<ScratchField> create_scratch_field_on_host(
        const std::string& name,
        int ncomp = 1,
        int nghost = 0,
        FieldLoc floc = FieldLoc::CELL) const;
 
    std::unique_ptr<ScratchField> create_scratch_field_on_host(
        int ncomp = 1, int nghost = 0, FieldLoc floc = FieldLoc::CELL) const;
 
    std::unique_ptr<IntScratchField> create_int_scratch_field_on_host(
        const std::string& name,
        int ncomp = 1,
        int nghost = 0,
        FieldLoc floc = FieldLoc::CELL) const;
 
    std::unique_ptr<IntScratchField> create_int_scratch_field_on_host(
        int ncomp = 1, int nghost = 0, FieldLoc floc = FieldLoc::CELL) const;

    void advance_states();

    const amrex::AmrCore& mesh() const { return m_mesh; }

    int num_active_levels() const { return m_mesh.finestLevel() + 1; }

    int num_fields() const { return static_cast<int>(m_field_vec.size()); }

    const amrex::Vector<std::unique_ptr<Field>>& fields() const
    {
        return m_field_vec;
    }

    const amrex::FabFactory<amrex::FArrayBox>& factory(int lev) const
    {
        return *m_leveldata[lev]->m_factory;
    }
 
protected:
    amrex::MultiFab& get_multifab(const unsigned fid, const int lev)
    {
        BL_ASSERT(lev <= m_mesh.finestLevel());
        return m_leveldata[lev]->m_mfabs[fid];
    }

    amrex::iMultiFab& get_int_fab(const unsigned fid, const int lev)
    {
        BL_ASSERT(lev <= m_mesh.finestLevel());
        return m_leveldata[lev]->m_int_fabs[fid];
    }

    Field& create_state(Field& field, FieldState fstate);

    void allocate_field_data(
        int lev,
        const Field& field,
        LevelDataHolder& level_data,
        const amrex::FabFactory<amrex::FArrayBox>& factory);

    void allocate_field_data(Field& field);

    void allocate_field_data(
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm,
        LevelDataHolder& level_data,
        const amrex::FabFactory<amrex::FArrayBox>& factory);
 
    void allocate_field_data(
        int lev, const IntField& field, LevelDataHolder& level_data);
 
    void allocate_field_data(const IntField& field);
 
    void allocate_field_data(
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm,
        LevelDataHolder& level_data,
        const amrex::FabFactory<amrex::IArrayBox>& factory);

    const amrex::AmrCore& m_mesh;

    amrex::Vector<std::unique_ptr<LevelDataHolder>> m_leveldata;

    mutable amrex::Vector<std::unique_ptr<Field>> m_field_vec;

    mutable amrex::Vector<std::unique_ptr<IntField>> m_int_field_vec;

    std::unordered_map<std::string, size_t> m_fid_map;

    std::unordered_map<std::string, size_t> m_int_fid_map;

    bool m_is_initialized{false};
};
 
} // namespace amr_wind
 
#endif /* FIELDREPO_H */