ABLStats.H

Go to the documentation of this file.

#ifndef ABLISTATS_H
#define ABLISTATS_H
 
#include "src/wind_energy/ABLStatsBase.H"
#include "src/CFDSim.H"
#include "src/transport_models/TransportModel.H"
#include "src/utilities/FieldPlaneAveraging.H"
#include "src/utilities/FieldPlaneAveragingFine.H"
#include "src/utilities/SecondMomentAveraging.H"
#include "src/utilities/ThirdMomentAveraging.H"
#include "src/utilities/PostProcessing.H"
#include "src/utilities/sampling/SamplerBase.H"
#include "src/utilities/sampling/SamplingContainer.H"
#include "src/wind_energy/ABLWallFunction.H"
#include "AMReX_REAL.H"
 
using namespace amrex::literals;
 
namespace kynema_sgf {
 
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*/, 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,
        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 KYNEMA_SGF_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_rt};

    amrex::Real m_kappa{0.41_rt};

    amrex::Real m_zi{0.0_rt};

    int m_normal_dir{2};

    amrex::Real m_dn{0.0_rt};

    size_t m_ncells_h1{0};
    size_t m_ncells_h2{0};

    bool m_do_energy_budget{false};
};
 
} // namespace kynema_sgf
 
#endif /* ABLISTATS_H */