Sampling.H

Go to the documentation of this file.

#ifndef SAMPLING_H
#define SAMPLING_H
 
#include <memory>
 
#include "amr-wind/CFDSim.H"
#include "amr-wind/utilities/DerivedQuantity.H"
#include "amr-wind/utilities/PostProcessing.H"
#include "amr-wind/utilities/sampling/SamplerBase.H"
#include "amr-wind/utilities/sampling/SamplingContainer.H"
#include <AMReX_PlotFileUtil.H>
#include "AMReX_REAL.H"
 
using namespace amrex::literals;

 
namespace amr_wind::sampling {

class Sampling : public PostProcessBase::Register<Sampling>
{
public:
    static std::string identifier() { return "Sampling"; }
 
    Sampling(CFDSim& /*sim*/, std::string /*label*/);
 
    ~Sampling() override;

    void pre_init_actions() override {}

    void initialize() override;

    void post_advance_work() override {};

    void output_actions() override;

    void post_regrid_actions() override;
 
    // Public for CUDA

    virtual void impl_write_native();
 
    void sampling_workflow();
    void sampling_post();
    void fill_buffer();
    void create_output_buffer();
    void convert_velocity_lineofsight();
 
    [[nodiscard]] int num_total_particles() const
    {
        return static_cast<int>(m_total_particles);
    }
 
#ifdef AMR_WIND_USE_NETCDF
    int num_netcdf_output_particles() const
    {
        if (m_out_fmt == "netcdf") {
            return static_cast<int>(m_netcdf_output_particles);
        }
        return 0;
    }
#endif
 
    [[nodiscard]] const amrex::Vector<std::string>& var_names() const
    {
        return m_var_names;
    }
 
protected:
    void update_container();

    void update_sampling_locations();

    virtual void process_output();

    virtual void prepare_netcdf_file();

    void write_netcdf();

    virtual void write_ascii();

    void write_header_file(const std::string& fname);

    void write_info_file(const std::string& fname);
 
    SamplingContainer& sampling_container() { return *m_scontainer; }
 
    static amrex::Vector<std::string> int_var_names()
    {
        return {"uid", "set_id", "probe_id"};
    };
 
private:
    CFDSim& m_sim;
 
    std::unique_ptr<SamplingContainer> m_scontainer;
    amrex::Vector<std::unique_ptr<SamplerBase>> m_samplers;

    amrex::Vector<std::string> m_var_names;

    amrex::Vector<Field*> m_fields;

    amrex::Vector<IntField*> m_int_fields;

    std::unique_ptr<DerivedQtyMgr> m_derived_mgr;

    const std::string m_label;

#ifdef AMR_WIND_USE_NETCDF
    std::string m_out_fmt{"netcdf"};
    std::string m_ncfile_name;
 
    // Current sample buffer for full container
    std::vector<amrex::Real> m_sample_buf;
 
    // Current sample buffer for output
    std::vector<amrex::Real> m_output_buf;

    size_t m_netcdf_output_particles{0};
#else
    std::string m_out_fmt{"native"};
#endif
 
    // Sample initial condition for interpolation consistency
    bool m_restart_sample{false};
 
    // number of field components
    int m_ncomp{0};
 
    // number of int field components
    int m_nicomp{0};
 
    // number of derived field components
    int m_ndcomp{0};

    size_t m_total_particles{0};
};
 
} // namespace amr_wind::sampling
 
#endif /* SAMPLING_H */