SnapshotCreator.h

Go to the documentation of this file.

#include <fstream>
#include <map>
#include <memory>
#include <ostream>
#include <valarray>
#include <vector>
 
#include "GenericManagingModule.h"
#include "GenericSubmodule.h"
#include "SimulationClassDefault.h"
 
template <typename T>
class SnapshotCreator
{
    private:
        std::ofstream m_global_ini_file_content;
        std::vector<std::string> m_save_fields{"Temperature"};
        void gatherIniFileContent(
            std::vector<std::shared_ptr<GenericManagingModule<double>>>& all_modules,
            std::vector<std::shared_ptr<GenericSubmodule<double>>>& all_submodules);
        void writeFields(SimulationClassBase<T>* sim);
 
    public:
        SnapshotCreator(SimulationClassBase<T>* sim,
                        std::vector<std::shared_ptr<GenericManagingModule<double>>>& all_modules,
                        std::vector<std::shared_ptr<GenericSubmodule<double>>>& all_submodules);
};
 
template <typename T>
SnapshotCreator<T>::SnapshotCreator(
    SimulationClassBase<T>* sim,
    std::vector<std::shared_ptr<GenericManagingModule<double>>>& all_modules,
    std::vector<std::shared_ptr<GenericSubmodule<double>>>& all_submodules)
{
    try
    {
        if (sim->m_simulation_config.getStringParameters("snapshot_save_file") == "None")
        {
            // I wanted to use return here, but this is apparently disallowed by the standard
            throw BadInput("String is None.");
        }
        m_global_ini_file_content.open(
            sim->m_simulation_config.getStringParameters("snapshot_save_file"),
            std::ios::binary | std::ios::out | std::ios::trunc);
        // Write the data from the specified fields (m_save_fields) into the snapshot.
        writeFields(sim);
        // Get and write the data from the simulation config (default.ini + user supplied run ini).
        std::unordered_map<std::string, std::any> ini_file_content{sim->m_simulation_config.data()};
        for (const auto& [key, map_content] : ini_file_content)
        {
            m_global_ini_file_content << "SimulationConfig" << "$" << key << " = "
                                      << std::any_cast<std::string>(map_content) << "\n";
        }
        // Get an write the data from the module ini files.
        gatherIniFileContent(all_modules, all_submodules);
        m_global_ini_file_content.close();
        std::cout << "\033[32m[SnapshotCreator] Successfully created snapshot file!\033[0m\n";
    }
    catch (const BadInput&)
    {
        // Do nothing here
    }
}
 
template <typename T>
void SnapshotCreator<T>::writeFields(SimulationClassBase<T>* sim)
{
    // I will probably add a little header with timestamp and maybe some more infos.
    m_global_ini_file_content << "FIELDDATA:\n";
    for (const auto& field_name : m_save_fields)
    {
        m_global_ini_file_content << field_name << "," << sim->elapsed_time << ",";
        const std::valarray<T>& field{sim->getField(field_name)};
        for (int i{0}; i < field.size() - 1; i++)
        {
            m_global_ini_file_content << field[i] << std::setprecision(15) << ",";
        }
        m_global_ini_file_content << field[field.size() - 1] << std::setprecision(15) << "\n";
    }
    m_global_ini_file_content << "INIFILEDATA:\n";
}
 
template <typename T>
void SnapshotCreator<T>::gatherIniFileContent(
    std::vector<std::shared_ptr<GenericManagingModule<double>>>& all_modules,
    std::vector<std::shared_ptr<GenericSubmodule<double>>>& all_submodules)
{
    for (auto& module : all_modules)
    {
        module->writeToGlobalIniContent(m_global_ini_file_content);
    }
 
    for (auto& submodule : all_submodules)
    {
        submodule->writeToGlobalIniContent(m_global_ini_file_content);
    }
}