SPADES.H

Go to the documentation of this file.

#ifndef SPADES_H
#define SPADES_H
#include <AMReX.H>
#include <AMReX_AmrCore.H>
#include <AMReX_MultiFab.H>
#include <AMReX_MultiFabUtil.H>
#include <AMReX_iMultiFab.H>
#include <AMReX_REAL.H>
#include <AMReX_ParmParse.H>
#include <AMReX_FluxRegister.H>
#include <AMReX_PlotFileUtil.H>
#include <AMReX_ErrorList.H>
#include <AMReX_Random.H>
#include "Constants.H"
#include "IC.H"
#include "Utilities.H"
#include "SpadesParticleContainer.H"
#include "MessageParticleContainer.H"
#include "EntityParticleContainer.H"
 
namespace spades {
 
class SPADES : public amrex::AmrCore
{
public:
    SPADES();
    ~SPADES() override;
 
    void init_data();
 
    void evolve();
 
    void MakeNewLevelFromCoarse(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm) override;
 
    void RemakeLevel(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm) override;
 
    void ClearLevel(int lev) override;
 
    void MakeNewLevelFromScratch(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm) override;
 
    void ErrorEst(
        int /*lev*/,
        amrex::TagBoxArray& /*tags*/,
        amrex::Real /*time*/,
        int /*ngrow*/) override
    {}
 
    static amrex::Real est_time_step();
 
    std::unique_ptr<amrex::MultiFab>
    get_field(const std::string& name, const int ngrow);
 
    void plot_file_mf();
 
    void initialize_state();
 
    void init_particle_containers();
 
    void process_messages();
 
    void rollback();
 
    void rollback_statistics();
 
    void update_gvt();
 
    void update_lbts();
 
    static constexpr int LEV{0};
 
private:
    void read_parameters();
 
    void compute_dt();
 
    void time_step(const amrex::Real time);
 
    void advance(const amrex::Real time, const amrex::Real dt);
 
    static void post_time_step();
 
    bool check_field_existence(const std::string& name);
 
    static int get_field_component(
        const std::string& name, const amrex::Vector<std::string>& varnames);
 
    void set_ics();
 
    [[nodiscard]] std::string plot_file_name(const int step) const;
 
    [[nodiscard]] std::string chk_file_name(const int step) const;
 
    [[nodiscard]] amrex::Vector<std::string> plot_file_var_names() const;
 
    void write_plot_file();
 
    void write_checkpoint_file() const;
 
    void read_checkpoint_file();
 
    void write_info_file(const std::string& path) const;
 
    void write_rng_file(const std::string& path) const;
 
    void read_rng_file(const std::string& path) const;
 
    void init_rng() const;
 
    void write_data_file(const bool is_init) const;
 
    void summary();
 
    int m_istep{0};
 
    amrex::Real m_gvt{constants::LOW_NUM};
 
    amrex::Real m_t_new{0.0};
 
    amrex::Real m_t_old{constants::LOW_NUM};
 
    amrex::Real m_dt{constants::LARGE_NUM};
 
    amrex::Real m_lbts{constants::LOW_NUM};
 
    amrex::Long m_ncells{0};
 
    amrex::Long m_ntotal_messages{0};
 
    amrex::Vector<amrex::Long> m_nmessages;
 
    amrex::Vector<amrex::Long> m_min_messages;
 
    amrex::Vector<amrex::Long> m_max_messages;
 
    amrex::Long m_nprocessed_messages{0};
 
    amrex::Long m_ntotal_entities{0};
 
    amrex::Long m_nentities{0};
 
    amrex::Vector<int> m_nrollbacks;
 
    amrex::Vector<amrex::Real> m_min_timings;
 
    amrex::Vector<amrex::Real> m_max_timings;
 
    amrex::Vector<amrex::Real> m_avg_timings;
 
    int m_max_step = std::numeric_limits<int>::max();
 
    amrex::Real m_stop_time = std::numeric_limits<amrex::Real>::max();
 
    amrex::Vector<std::string> m_spades_varnames;
 
    amrex::Vector<std::string> m_state_varnames;
 
    amrex::Vector<std::string> m_message_counts_varnames;
 
    amrex::Vector<std::string> m_entity_counts_varnames;
 
    amrex::MultiFab m_state;
 
    amrex::MultiFab m_plt_mf;
 
    const int m_state_ngrow = 0;
 
    std::string m_restart_chkfile;
 
    std::string m_plot_file{"plt"};
 
    int m_plot_int = -1;
 
    std::string m_chk_file{"chk"};
 
    int m_chk_int = -1;
 
    int m_nfiles{constants::TWO_TO_EIGHT};
 
    int m_file_name_digits{constants::FILE_NAME_DIGITS};
 
    int m_rng_file_name_digits{constants::RNG_FILE_NAME_DIGITS};
 
    bool m_write_messages{false};
 
    bool m_write_entities{false};
 
    std::string m_data_fname{"data.csv"};
 
    const int m_data_precision{6};
 
    amrex::Real m_lookahead{1.0};
 
    amrex::Real m_window_size{constants::LARGE_NUM};
 
    int m_messages_per_step{1};
 
    int m_entities_per_lp{1};
 
    int m_messages_per_lp{1};
 
    int m_seed{0};
 
    amrex::Real m_lambda{1.0};
 
    std::unique_ptr<ic::InitializerBase> m_ic_op;
 
    std::string m_ic_type;
 
    std::unique_ptr<particles::MessageParticleContainer> m_message_pc;
 
    std::unique_ptr<particles::EntityParticleContainer> m_entity_pc;
};
} // namespace spades
#endif