SamplerBase.H

Go to the documentation of this file.

#ifndef SAMPLERBASE_H
#define SAMPLERBASE_H
 
#include <AMReX_RealVect.H>
#include "amr-wind/core/Factory.H"
#include "amr-wind/utilities/ncutils/nc_interface.H"
#include "amr-wind/utilities/constants.H"
#include "AMReX_REAL.H"
 
using namespace amrex::literals;
 
namespace amr_wind {
 
class CFDSim;
 
namespace sampling {
 
struct SampleLocType
{
    using LocType = amrex::Vector<amrex::RealVect>;
    using IdType = amrex::Vector<amrex::Long>;
 
    void push_back(const amrex::RealVect& loc, const amrex::Long id)
    {
        m_locations.push_back(loc);
        m_ids.push_back(id);
    }
 
    const LocType& locations() const
    {
        AMREX_ALWAYS_ASSERT(m_locations.size() == m_ids.size());
        return m_locations;
    }
 
    LocType& locations()
    {
        AMREX_ALWAYS_ASSERT(m_locations.size() == m_ids.size());
        return m_locations;
    }
 
    const IdType& ids() const
    {
        AMREX_ALWAYS_ASSERT(m_locations.size() == m_ids.size());
        return m_ids;
    }
 
    LocType m_locations;
    IdType m_ids;
};

class SamplerBase : public Factory<SamplerBase, CFDSim&>
{
public:
    static std::string base_identifier() { return "SamplerBase"; }
 
    static constexpr amrex::Real bounds_tol = constants::TIGHT_TOL;
 
    ~SamplerBase() override = default;

    virtual std::string label() const = 0;
    virtual std::string& label() = 0;

    virtual std::string sampletype() const = 0;

    virtual int id() const = 0;
    virtual int& id() = 0;

    virtual long num_points() const = 0;

    virtual long num_output_points() const = 0;

    virtual void initialize(const std::string& key) = 0;

    virtual void sampling_locations(SampleLocType&) const = 0;

    virtual void
    sampling_locations(SampleLocType&, const amrex::Box&) const = 0;

    virtual void check_bounds() = 0;

    virtual void output_locations(SampleLocType&) const = 0;

    virtual bool update_sampling_locations() { return false; }

    virtual void post_sample_actions() {}

    virtual void post_regrid_actions() {}

    virtual bool output_netcdf_field(
        const std::vector<amrex::Real>& /*unused*/,
        ncutils::NCGroup& /*unused*/,
        const size_t /*unused*/)
    {
        return true;
    }

    virtual bool do_data_modification() { return false; }
    virtual bool do_convert_velocity_los() { return false; }
    virtual bool do_subsampling_interp() { return false; }

    virtual std::vector<amrex::Real> modify_sample_data(
        const std::vector<amrex::Real>& sampledata,
        const std::string& /*unused*/)
    {
        return sampledata;
    }
 
    virtual void calc_lineofsight_velocity(
        const std::vector<std::vector<amrex::Real>>& /*unused*/,
        const int /*unused*/)
    {}

    virtual void
    define_netcdf_metadata(const ncutils::NCGroup& /*unused*/) const
    {}
    virtual void
    populate_netcdf_metadata(const ncutils::NCGroup& /*unused*/) const
    {}
    virtual void output_netcdf_data(
        const ncutils::NCGroup& /*unused*/, const size_t /*unused*/) const
    {}
};
 
} // namespace sampling
} // namespace amr_wind
 
#endif /* SAMPLERBASE_H */