RANSConvergence.H

Go to the documentation of this file.

#ifndef RANSCONVERGENCE_H
#define RANSCONVERGENCE_H
 
#include <memory>
#include <string>
 
#include "src/CFDSim.H"
#include "src/utilities/PostProcessing.H"
#include "src/utilities/sampling/SamplerBase.H"
#include "src/utilities/sampling/SamplingContainer.H"
#include "AMReX_REAL.H"
#include "AMReX_Vector.H"
 
using namespace amrex::literals;
 
namespace kynema_sgf::rans_convergence {

struct EnvelopeFit
{
    bool valid{false};

    amrex::Real rate{0.0_rt};

    amrex::Real amplitude{0.0_rt};

    amrex::Real rsq{0.0_rt};

    amrex::Real time_to_threshold{-1.0_rt};
};

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

    void pre_init_actions() override {}

    void initialize() override;

    void post_advance_work() override;

    void output_actions() override {}

    void post_regrid_actions() override;

    static EnvelopeFit fit_envelope_decay(
        const amrex::Vector<amrex::Real>& times,
        const amrex::Vector<amrex::Real>& spreads,
        amrex::Real threshold,
        int min_samples);

    static amrex::Real effective_tolerance(
        const amrex::Real mean,
        const amrex::Real abs_tol,
        const amrex::Real rel_tol)
    {
        return amrex::max<amrex::Real>(abs_tol, rel_tol * std::abs(mean));
    }
 
private:
    void check_turbulence_model() const;

    void setup_container();

    void reject_terrain_points();

    void take_sample();

    void evaluate_convergence();

    void prepare_ascii_file();

    void write_ascii(
        int num_samples,
        bool window_full,
        amrex::Real hold_elapsed,
        int num_converged,
        int worst_vel_point,
        amrex::Real worst_vel_spread,
        amrex::Real worst_vel_tol,
        int worst_tke_point,
        amrex::Real worst_tke_spread,
        amrex::Real worst_tke_tol,
        amrex::Real eta);

    CFDSim& m_sim;

    const std::string m_label;

    std::unique_ptr<sampling::SamplerBase> m_sampler;

    std::unique_ptr<sampling::SamplingContainer> m_scontainer;

    amrex::Vector<Field*> m_fields;

    amrex::Vector<amrex::Real> m_point_coords;

    int m_npts{0};

    int m_ncomp_total{0};

    bool m_has_terrain{false};

    amrex::Vector<amrex::Real> m_sample_buf;

    amrex::Real m_start_time{-1.0_rt};

    amrex::Real m_sample_interval{-1.0_rt};

    amrex::Real m_window{-1.0_rt};

    amrex::Real m_vel_abs_tol{0.01_rt};

    amrex::Real m_vel_rel_tol{0.001_rt};

    amrex::Real m_tke_abs_tol{0.001_rt};

    amrex::Real m_tke_rel_tol{0.01_rt};

    int m_min_samples{4};

    amrex::Real m_hold_time{-1.0_rt};

    amrex::Real m_converged_since{-1.0_rt};

    bool m_stop_on_convergence{true};

    bool m_report_eta{true};

    amrex::Real m_eta_fit_window{-1.0_rt};

    int m_eta_min_samples{5};

    amrex::Real m_eta_min_rsq{0.5_rt};

    amrex::Real m_next_sample_time{0.0_rt};

    amrex::Vector<amrex::Real> m_times;

    amrex::Vector<amrex::Vector<amrex::Real>> m_samples;

    amrex::Vector<amrex::Real> m_eta_times;

    amrex::Vector<amrex::Real> m_eta_vel_ratio;

    amrex::Vector<amrex::Real> m_eta_tke_ratio;

    bool m_converged{false};

    std::string m_out_fname;

    int m_width{18};

    int m_precision{10};
};
 
} // namespace kynema_sgf::rans_convergence
 
#endif /* RANSCONVERGENCE_H */