SimulationClassBase.h

Go to the documentation of this file.

#ifndef SIMULATION_CLASS_BASE_H
#define SIMULATION_CLASS_BASE_H
 
#ifdef MPI_PRESENT
#include <mpi.h>
#endif
 
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <valarray>
 
#include "DenseMatrix.h"
#include "InputManager.h"
 
template <typename T>
class SimulationClassBase
{
    public:
        SimulationClassBase();
        SimulationClassBase(const int argc, const char* argv[]);
        SimulationClassBase(const std::string& user_ini);
 
        std::map<std::string, std::valarray<T>> m_field_map{};
        std::string_view
            m_current_position;  // make sure it always points to a valid std::string member
 
        InputManager m_simulation_config{"ini_files/default.ini"};
 
        T elapsed_time{0};
        // Track time step too, to avoid rounding error in elapsed time for modules that need the
        // exact time step.
        int time_step{0};
 
        int my_rank{0};
        int world_size{1};
 
#ifdef MPI_PRESENT
        int my_sub_rank, sub_size, my_inter_rank;  // rank and size variables
        int my_color, remote_leader, global_array_split,
            other_color_exists;  // Helper variables for subcomm and intercomm creation
        int number_of_larger_procs,
            min_number_facets_per_proc;  // Helper variables for domain decomp.
        T local_convergence_diff;        // This variable only gets used with MPI
        T global_convergence_diff;       // This variable only gets used with MPI
        MPI_Comm sub_comm, inter_comm;
#endif
 
        // These getters seem wasteful, but I did it to encapsulate the strings as nothing should be
        // able to change them at run time.
        void setInitChainStr() { m_current_position = m_init_str; };
        void setPreTimeStepChainStr() { m_current_position = m_preTs_str; };
        void setPostTimeStepChainStr() { m_current_position = m_postTs_str; };
        void setPostNonLinIterChainStr() { m_current_position = m_postNonLinIter_str; };
        void setOutputChainStr() { m_current_position = m_output_str; };
 
        virtual void setUserIni(const std::string& user_ini);
        void printField(const std::string& key);
        const std::valarray<T>& getField(const std::string& key) const;
        const T& getFieldValue(const std::string& key, int pos) const;
 
        virtual int run() = 0;
 
        virtual ~SimulationClassBase() = default;
 
    private:
        std::string m_init_str{"InitChain"};
        std::string m_preTs_str{"PreTimeStepChain"};
        std::string m_postTs_str{"PostTimeStepChain"};
        std::string m_postNonLinIter_str{"PostNonLinIterChain"};
        std::string m_output_str{"OutputChain"};
};
 
template <typename T>
SimulationClassBase<T>::SimulationClassBase()
{
}
 
template <typename T>
SimulationClassBase<T>::SimulationClassBase(const int argc, const char* argv[])
{
    // Merge build metadata into configuration
    m_simulation_config.addBuildInfo();
 
    // Parse command line arguments such as ini file and overrides
    m_simulation_config.parseCommandLineArguments(
        argc, argv, m_simulation_config.getStringParameters("ini_folder_path"));
}
 
template <typename T>
SimulationClassBase<T>::SimulationClassBase(const std::string& user_ini)
{
    // Merge build metadata into configuration
    m_simulation_config.addBuildInfo();
 
    // Load the ini file
    m_simulation_config.loadUserInput(m_simulation_config.getStringParameters("ini_folder_path")
                                      + user_ini);
}
 
template <typename T>
const std::valarray<T>& SimulationClassBase<T>::getField(const std::string& key) const
{
    return m_field_map.at(key);
}
 
template <typename T>
const T& SimulationClassBase<T>::getFieldValue(const std::string& key, int pos) const
{
    return m_field_map.at(key)[pos];
}
 
template <typename T>
void SimulationClassBase<T>::setUserIni(const std::string& user_ini)
{
    m_simulation_config.loadUserInput(m_simulation_config.getStringParameters("ini_folder_path")
                                      + user_ini);
}
 
template <typename T>
void SimulationClassBase<T>::printField(const std::string& key)
{
    std::cout << key << ": ";
    for (const auto& val : m_field_map[key])
    {
        std::cout << val << ' ';
    }
    std::cout << "\n";
}
 
#endif