ABLStats.H

Go to the documentation of this file.

#ifndef ABLISTATS_H
#define ABLISTATS_H
 
#include "amr-wind/wind_energy/ABLStatsBase.H"
#include "amr-wind/CFDSim.H"
#include "amr-wind/utilities/FieldPlaneAveraging.H"
#include "amr-wind/utilities/FieldPlaneAveragingFine.H"
#include "amr-wind/utilities/SecondMomentAveraging.H"
#include "amr-wind/utilities/ThirdMomentAveraging.H"
#include "amr-wind/utilities/PostProcessing.H"
#include "amr-wind/utilities/sampling/SamplerBase.H"
#include "amr-wind/utilities/sampling/SamplingContainer.H"
#include "amr-wind/wind_energy/ABLWallFunction.H"
 
namespace amr_wind {
 
namespace pde::icns {
class ABLForcing;
class ABLMesoForcingMom;
} // namespace pde::icns
 
namespace pde::temperature {
class ABLMesoForcingTemp;
}
 
class ABLStats : public ABLStatsBase::Register<ABLStats>
{
public:
    static std::string identifier() { return "precursor"; }
 
    ABLStats(
        CFDSim& /*sim*/,
        const ABLWallFunction& /*abl_wall_func*/,
        const int dir);
 
    ~ABLStats() override;
 
    ABLStatsMode abl_mode() const override { return ABLStatsMode::computed; }
 
    // Perform initialization actions after the mesh has been created
    void post_init_actions() override;
 
    void pre_advance_work() override {}
 
    void post_advance_work() override;
 
    void compute_zi();
 
    const VelPlaneAveragingFine& vel_profile() const override
    {
        return m_pa_vel_fine;
    };
 
    const VelPlaneAveraging& vel_profile_coarse() const override
    {
        return m_pa_vel;
    };
 
    const FieldPlaneAveraging& theta_profile() const override
    {
        return m_pa_temp;
    }
 
    const FieldPlaneAveragingFine& theta_profile_fine() const override
    {
        return m_pa_temp_fine;
    }
 
    void register_forcing_term(pde::icns::ABLForcing* forcing) const override
    {
        m_abl_forcing = forcing;
    }
 
    void register_meso_mom_forcing(
        pde::icns::ABLMesoForcingMom* forcing) const override
    {
        m_abl_meso_mom_forcing = forcing;
    }
 
    void register_meso_temp_forcing(
        pde::temperature::ABLMesoForcingTemp* forcing) const override
    {
        m_abl_meso_temp_forcing = forcing;
    }
 
    void
    calc_sfs_stress_avgs(ScratchField& sfs_stress, ScratchField& t_sfs_stress);
 
    void calc_tke_diffusion(
        ScratchField& diffusion,
        const Field& buoy_prod,
        const Field& shear_prod,
        const Field& dissipation,
        const amrex::Real dt);
 
protected:
    void initialize();
 
    void calc_averages();
 
    virtual void process_output();
 
    virtual void prepare_ascii_file();
    virtual void prepare_netcdf_file();
 
    void write_netcdf();
 
    virtual void write_ascii();
 
private:
    CFDSim& m_sim;
    const ABLWallFunction& m_abl_wall_func;
    Field& m_temperature;
    Field& m_mueff;
 
    VelPlaneAveraging m_pa_vel;
    FieldPlaneAveraging m_pa_temp;
    VelPlaneAveragingFine m_pa_vel_fine;
    FieldPlaneAveragingFine m_pa_temp_fine;
    FieldPlaneAveraging m_pa_mueff;
    SecondMomentAveraging m_pa_tt;
    SecondMomentAveraging m_pa_tu;
    SecondMomentAveraging m_pa_uu;
    ThirdMomentAveraging m_pa_uuu;
 
    mutable pde::icns::ABLForcing* m_abl_forcing{nullptr};
 
    mutable pde::icns::ABLMesoForcingMom* m_abl_meso_mom_forcing{nullptr};
    mutable pde::temperature::ABLMesoForcingTemp* m_abl_meso_temp_forcing{
        nullptr};
 
#ifdef AMR_WIND_USE_NETCDF
    std::string m_out_fmt{"netcdf"};
    std::string m_ncfile_name;
#else
    std::string m_out_fmt{"ascii"};
#endif
    std::string m_ascii_file_name;
 
    int m_out_freq{100};
 
    amrex::Real m_gravity{9.81};
 
    amrex::Real m_kappa{0.41};
 
    amrex::Real m_ref_theta{300.0};
 
    amrex::Real m_zi{0.0};
 
    int m_normal_dir{2};
 
    amrex::Real m_dn{0.0};
 
    size_t m_ncells_h1{0};
    size_t m_ncells_h2{0};
 
    bool m_do_energy_budget{false};
};
 
} // namespace amr_wind
 
#endif /* ABLISTATS_H */