ABLBoundaryPlane.H

Go to the documentation of this file.

#ifndef ABLBOUNDARYPLANE_H
#define ABLBOUNDARYPLANE_H
 
#include "amr-wind/core/Field.H"
#include "amr-wind/CFDSim.H"
#include "AMReX_Gpu.H"
#include "amr-wind/utilities/ncutils/nc_interface.H"
#include "amr-wind/utilities/io_utils.H"
#include <AMReX_BndryRegister.H>
 
#include "amr-wind/wind_energy/ABLReadERFFunction.H"
class MultiBlockContainer;
namespace amr_wind {
 
enum struct io_mode { output, input, undefined };
 
struct BufferData
{
    amrex::Gpu::ManagedVector<amrex::Real> data;
    amrex::Vector<size_t> start{0, 0, 0, 0};
    amrex::Vector<size_t> count{0, 0, 0, 0};
};
struct BufferData {…};
 
class InletData
{
    using PlaneVector = amrex::Vector<amrex::FArrayBox>;
 
public:
    InletData() = default;
 
    void resize(const int /*size*/);
 
    void define_plane(const amrex::Orientation /*ori*/);
 
    void define_level_data(
        const amrex::Orientation /*ori*/,
        const amrex::Box& /*bx*/,
        const size_t /*nc*/);
 
#ifdef AMR_WIND_USE_NETCDF
    void read_data(
        ncutils::NCGroup& /*grp*/,
        const amrex::Orientation /*ori*/,
        const int /*lev*/,
        const Field* /*fld*/,
        const amrex::Real /*time*/,
        const amrex::Vector<amrex::Real>& /*times*/);
#endif
 
    void read_data_native(
        const amrex::OrientationIter oit,
        amrex::BndryRegister& bndry_n,
        amrex::BndryRegister& bndry_np1,
        const int lev,
        const Field* /*fld*/,
        const amrex::Real time,
        const amrex::Vector<amrex::Real>& /*times*/);
 
    void interpolate(const amrex::Real /*time*/);
    bool is_populated(amrex::Orientation /*ori*/) const;
    const amrex::FArrayBox&
    interpolate_data(const amrex::Orientation ori, const int lev) const
    {
        return (*m_data_interp[ori])[lev];
    }
    interpolate_data(const amrex::Orientation ori, const int lev) const {…}
 
    int& component(const int id) { return m_components[id]; }
 
    int component(const int id) const { return m_components.at(id); }
 
    int nlevels(const amrex::Orientation ori) const
    {
        return static_cast<int>((*m_data_interp[ori]).size());
    }
    int nlevels(const amrex::Orientation ori) const {…}
 
    amrex::Real tn() const { return m_tn; }
    amrex::Real tnp1() const { return m_tnp1; }
    amrex::Real tinterp() const { return m_tinterp; }
 
private:
    amrex::Vector<std::unique_ptr<PlaneVector>> m_data_n;
    amrex::Vector<std::unique_ptr<PlaneVector>> m_data_np1;
    amrex::Vector<std::unique_ptr<PlaneVector>> m_data_interp;
 
    amrex::Real m_tn{-1.0};
 
    amrex::Real m_tnp1{-1.0};
 
    amrex::Real m_tinterp{-1.0};
 
    std::unordered_map<int, int> m_components;
};
class InletData {…};
 
class ABLBoundaryPlane
{
    static_assert(AMREX_SPACEDIM == 3, "ABL requires 3 dimensional mesh");
 
public:
    explicit ABLBoundaryPlane(CFDSim& /*sim*/);
 
    void post_init_actions();
 
    void pre_advance_work();
 
    void pre_predictor_work();
 
    void post_advance_work();
 
    void initialize_data();
 
    void write_header();
 
    void write_bndry_native_header(const std::string& chkname);
 
    void write_file();
 
    void read_header();
 
    amrex::Vector<amrex::BoxArray> read_bndry_native_boxarrays(
        const std::string& chkname, const Field& field) const;
 
    void read_file(const bool /* nph_target_time*/);
 
    void populate_data(
        const int /*lev*/,
        const amrex::Real /*time*/,
        Field& /*fld*/,
        amrex::MultiFab& /*mfab*/,
        const int dcomp = 0,
        const int orig_comp = 0) const;
 
#ifdef AMR_WIND_USE_NETCDF
    static void impl_buffer_field(
        const amrex::Box& /*bx*/,
        const int /*n1*/,
        const int /*nc*/,
        const amrex::GpuArray<int, 2>& /*perp*/,
        const amrex::IntVect& /*v_offset*/,
        const amrex::Array4<const amrex::Real>& /*fld*/,
        amrex::Gpu::ManagedVector<amrex::Real>& /*buffer*/);
#endif
 
    bool is_initialized() const { return m_is_initialized; }
 
    bool box_intersects_boundary(
        const amrex::Box& /*bx*/,
        const int /*lev*/,
        const amrex::Orientation /*ori*/) const;
 
    bool is_data_newer_than(const amrex::Real time) const
    {
        return (m_in_data.tinterp() - time > 1e-12);
    }
    bool is_data_newer_than(const amrex::Real time) const {…}
 
    io_mode mode() const { return m_io_mode; }
 
    MultiBlockContainer* mbc()
    {
        // Make sure that the double pointer m_mbc
        // does not point to a nullptr
        // before passing *m_mbc for use
        if ((*m_mbc) == nullptr) {
            amrex::Abort("Passing a null pointer for use!");
        }
        return *m_mbc;
    }
    MultiBlockContainer* mbc() {…}
 
private:
    const amr_wind::SimTime& m_time;
    const FieldRepo& m_repo;
    const amrex::AmrCore& m_mesh;
 
    // pointer to pointer : when ABL boundary plane gets initialized, amr-wind
    // CFDsim does not yet have the up to date pointer to the mbc or the
    // read_erf function, hence the use of double pointers
    MultiBlockContainer** m_mbc;
    ReadERFFunction* m_read_erf{nullptr};
 
#ifdef AMR_WIND_USE_NETCDF
    void write_data(
        const ncutils::NCGroup& grp,
        const amrex::Orientation /*ori*/,
        const int /*lev*/,
        const Field* /*fld*/);
#endif
    int boundary_native_file_levels() const;
 
    std::string m_title{"ABL boundary planes"};
 
    int m_write_frequency{1};
 
    amrex::Vector<std::string> m_plane_names{"xlo", "ylo", "zlo",
                                             "xhi", "yhi", "zhi"};
    amrex::Vector<std::string> m_plane_names{"xlo", "ylo", "zlo", {…};
 
    amrex::Vector<std::string> m_planes;
 
    amrex::Real m_out_start_time{0.0};
 
#ifdef AMR_WIND_USE_NETCDF
    size_t m_out_counter{0};
#endif
 
    std::string m_filename;
 
    std::string m_time_file;
 
    amrex::Vector<std::string> m_var_names;
 
    amrex::Vector<Field*> m_fields;
 
    amrex::Vector<amrex::Real> m_in_times;
    amrex::Vector<int> m_in_timesteps;
 
    InletData m_in_data;
 
    io_mode m_io_mode{io_mode::undefined};
 
    bool m_is_initialized{false};
 
    const int m_in_rad = 1;
    const int m_out_rad = 1;
    const int m_extent_rad = 0;
 
    std::string m_out_fmt{"native"};
};
class ABLBoundaryPlane {…};
 
} // namespace amr_wind
 
#endif /* ABLBOUNDARYPLANE_H */