SimTime.H

Go to the documentation of this file.

#ifndef SIMTIME_H
#define SIMTIME_H
 
#include "AMReX_REAL.H"
#include "AMReX_GpuQualifiers.H"
#include "AMReX_Extension.H"
#include "AMReX_Vector.H"
#include <algorithm>
#include <cmath>
 
using namespace amrex::literals;
 
namespace {
AMREX_FORCE_INLINE amrex::Real get_enforced_dt_for_output(
    const amrex::Real dt,
    const amrex::Real cur_time,
    const amrex::Real interval,
    const amrex::Real tol)
{
    // Tolerance for being slightly under is relative to requested interval
    return amrex::min<amrex::Real>(
        dt, ((std::floor((cur_time / interval) + tol) + 1.0_rt) * interval) -
                cur_time);
}
} // namespace
 
namespace amr_wind {

class SimTime
{
public:
    static constexpr int max_time_states = 3;
 
    SimTime() = default;
 
    ~SimTime() = default;

    bool new_timestep();

    [[nodiscard]] bool continue_simulation() const;

    [[nodiscard]] bool do_regrid() const;

    [[nodiscard]] bool write_plot_file() const;

    [[nodiscard]] bool write_checkpoint() const;

    [[nodiscard]] bool write_last_plot_file() const;

    [[nodiscard]] bool write_last_checkpoint() const;

    void set_current_cfl(
        amrex::Real conv_cfl, amrex::Real diff_cfl, amrex::Real src_cfl);

    void advance_time();

    void set_restart_time(int tidx, amrex::Real time);
 
    AMREX_FORCE_INLINE
    amrex::Real delta_t() const { return m_dt[0]; }
 
    AMREX_FORCE_INLINE
    amrex::Real& delta_t() { return m_dt[0]; }
 
    AMREX_FORCE_INLINE
    amrex::Real delta_t_nm1() const { return m_dt[1]; }
 
    AMREX_FORCE_INLINE
    amrex::Real delta_t_nm2() const { return m_dt[2]; }
 
    AMREX_FORCE_INLINE
    amrex::Real& delta_t_nm1() { return m_dt[1]; }
 
    AMREX_FORCE_INLINE
    amrex::Real& delta_t_nm2() { return m_dt[2]; }
 
    AMREX_FORCE_INLINE
    amrex::Real current_time() const { return m_cur_time; }
 
    AMREX_FORCE_INLINE
    amrex::Real& current_time() { return m_cur_time; }
 
    AMREX_FORCE_INLINE
    amrex::Real new_time() const { return m_new_time; }
 
    AMREX_FORCE_INLINE
    amrex::Real max_cfl() const { return m_max_cfl; }
 
    AMREX_FORCE_INLINE
    amrex::Real get_minimum_enforce_dt_abs_tol() const
    {
        return m_force_dt_abs_tol;
    }
 
    AMREX_FORCE_INLINE
    int time_index() const { return m_time_index; }
 
    AMREX_FORCE_INLINE
    int& time_index() { return m_time_index; }
 
    AMREX_FORCE_INLINE
    bool adaptive_timestep() const { return m_adaptive; }
 
    AMREX_FORCE_INLINE
    bool use_force_cfl() const { return m_use_force_cfl; }
 
    AMREX_FORCE_INLINE
    int regrid_interval() const { return m_regrid_interval; }
 
    AMREX_FORCE_INLINE
    amrex::Real start_time() const { return m_start_time; }
 
    AMREX_FORCE_INLINE
    amrex::Real stop_time() const { return m_stop_time; }
 
    AMREX_FORCE_INLINE
    int start_time_index() const { return m_start_time_index; }
 
    AMREX_FORCE_INLINE
    int stop_time_index() const { return m_stop_time_index; }
 
    AMREX_FORCE_INLINE
    int chkpt_interval() const { return m_chkpt_interval; }

    void parse_parameters();

    void add_postproc_dt_parameters(
        const bool enforce_dt_flag,
        const amrex::Real enforce_dt_tol,
        const amrex::Real time_interval,
        const amrex::Real time_delay)
    {
        m_postprocess_enforce_dt.emplace_back(enforce_dt_flag);
        m_postprocess_enforce_dt_tol.emplace_back(enforce_dt_tol);
        m_postprocess_time_interval.emplace_back(time_interval);
        m_postprocess_time_delay.emplace_back(time_delay);
    }

    void calculate_minimum_enforce_dt_abs_tol();

    void override_simulation_end_parameters()
    {
        m_stop_time_index = -1;
        m_stop_time = -1.0_rt;
    }

    [[nodiscard]] bool output_profiling_info() const;
 
private:
    amrex::Vector<amrex::Real> m_dt =
        amrex::Vector<amrex::Real>(max_time_states, 0.0_rt);

    amrex::Real m_cur_time{0.0_rt};

    amrex::Real m_new_time{0.0_rt};

    amrex::Real m_start_time{0.0_rt};

    amrex::Real m_stop_time{-1.0_rt};

    amrex::Real m_delay_time{-1.0_rt};

    amrex::Real m_max_cfl{1.0_rt};

    amrex::Real m_fixed_dt{-1.0_rt};

    amrex::Real m_initial_dt{-1.0_rt};

    amrex::Real m_max_dt{-1.0_rt};

    amrex::Real m_min_dt{-1.0_rt};

    amrex::Real m_current_cfl{0.0_rt};

    amrex::Real m_conv_cfl{0.0_rt};
    amrex::Real m_diff_cfl{0.0_rt};
    amrex::Real m_src_cfl{0.0_rt};

    amrex::Real m_dt_calc{0.0_rt};

    amrex::Real m_init_shrink{0.1_rt};

    amrex::Real m_dt_growth{0.1_rt};

    amrex::Real m_chkpt_t_interval{-1.0_rt};

    amrex::Real m_chkpt_t_delay{0.0_rt};

    amrex::Real m_chkpt_t_tol{std::numeric_limits<float>::epsilon() * 1.0e1_rt};

    amrex::Real m_force_chkpt_tol{1.0e-3_rt};

    amrex::Real m_plt_t_interval{-1.0_rt};

    amrex::Real m_plt_t_delay{0.0_rt};

    amrex::Real m_plt_t_tol{std::numeric_limits<float>::epsilon() * 1.0e1_rt};

    amrex::Real m_force_plt_tol{1.0e-3_rt};

    amrex::Real m_force_dt_abs_tol{1.0e8_rt};

    amrex::Real m_chkpt_start_time{0.0_rt};

    amrex::Real m_plt_start_time{0.0_rt};

    int m_time_index{0};

    int m_start_time_index{0};

    int m_chkpt_start_index{0};

    int m_plt_start_index{0};

    int m_regrid_start_index{0};

    int m_stop_time_index{-1};

    int m_chkpt_interval{-1};

    int m_chkpt_delay{0};

    int m_plt_interval{-1};

    int m_plt_delay{0};

    int m_regrid_interval{-1};

    int m_profiling_interval{-1};

    int m_verbose{0};

    bool m_adaptive{false};

    bool m_is_init{true};

    bool m_use_force_cfl{true};

    bool m_force_chkpt_dt{false};

    bool m_force_plt_dt{false};

    std::vector<bool> m_postprocess_enforce_dt;
    amrex::Vector<amrex::Real> m_postprocess_enforce_dt_tol;
    amrex::Vector<amrex::Real> m_postprocess_time_interval;
    amrex::Vector<amrex::Real> m_postprocess_time_delay;
};
 
} // namespace amr_wind
 
#endif /* SIMTIME_H */