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"
 
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 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();
 
    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
 
    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_info_file(const std::string& fname);
 
    SamplingContainer& sampling_container() { return *m_scontainer; }
 
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<double> m_sample_buf;
 
    // Current sample buffer for output
    std::vector<double> 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};
 
    int m_out_freq{100};
 
    int m_out_delay{0};
};
 
} // namespace amr_wind::sampling
 
#endif /* SAMPLING_H */