SnapshotLoader.h

Go to the documentation of this file.

#include <memory>
#include <valarray>
#include <vector>
 
#include "CsvParser.h"
#include "GenericManagingModule.h"
#include "GenericSubmodule.h"
#include "IniParser.h"
#include "SimulationClassDefault.h"
 
template <typename T>
class SnapshotLoader
{
    private:
        std::unique_ptr<CsvParser> m_snapshot_field_data;
        std::unique_ptr<IniParserSnapshot> m_snapshot_ini_data;
        bool m_no_snapshot{false};
        bool m_keep_sim_config{false};
        bool m_keep_module_inis{false};
 
    public:
        SnapshotLoader(SimulationClassBase<T>* sim);
 
        void overwriteSimFields(SimulationClassBase<T>* sim);
        void overwriteIniFiles(SimulationClassBase<T>* sim,
                               std::vector<std::shared_ptr<GenericManagingModule<T>>>& all_modules,
                               std::vector<std::shared_ptr<GenericSubmodule<T>>>& all_submodules);
        void overwriteSimConfig(SimulationClassBase<T>* sim);
};
 
template <typename T>
SnapshotLoader<T>::SnapshotLoader(SimulationClassBase<T>* sim)
{
    // Check if sim config or module ini file retention is selected.
    try
    {
        m_keep_sim_config = sim->m_simulation_config.getBoolParameters("_snapshot_keep_sim");
    }
    catch (BadInput)
    {
        // Do nothing here
    }
    try
    {
        m_keep_module_inis = sim->m_simulation_config.getBoolParameters("_snapshot_keep_module");
    }
    catch (BadInput)
    {
        // Do nothing here
    }
 
    // If a snapshot is given, load it. If not, do nothing, as the user won't have requested a load.
    try
    {
        std::cout << sim->m_simulation_config.getStringParameters("snapshot") << "\n";
        if (sim->m_simulation_config.getStringParameters("snapshot") == "None")
        {
            // I wanted to use return here, but this is apparently disallowed by the standard
            throw BadInput("String is None.");
        }
        std::string filename{sim->m_simulation_config.getStringParameters("snapshot")};
        std::string filetype{"snapshot"};
        m_snapshot_field_data = std::make_unique<CsvParser>(filename, filetype);
        m_snapshot_ini_data = std::make_unique<IniParserSnapshot>(filename);
        std::cout << "\033[32m[SnapshotLoader] Successfully read snapshot file: "
                  << sim->m_simulation_config.getStringParameters("snapshot") << "\033[0m\n";
    }
    catch (BadInput)
    {
        m_no_snapshot = true;
    }
}
 
template <typename T>
void SnapshotLoader<T>::overwriteSimFields(SimulationClassBase<T>* sim)
{
    if (m_no_snapshot)
    {
        return;
    }
    std::vector<std::vector<T>> all_fields_content;
    std::vector<std::string> all_field_names;
    double elapsed_time{0.0};
 
    m_snapshot_field_data->getSnapshotContents(all_fields_content, all_field_names, elapsed_time);
 
    // For each field that is part of the snapshot
    for (int i{0}; i < all_field_names.size(); i++)
    {
        // Write the snapshot data into the field map. Can't just copy here due to valarray vector
        // mismatch.
        for (int j{0}; j < all_fields_content[i].size(); j++)
        {
            sim->m_field_map[all_field_names[i]][j] = all_fields_content[i][j];
        }
    }
 
    sim->elapsed_time = elapsed_time;
    sim->time_step = int(elapsed_time / sim->m_simulation_config.getDoubleParameters("time_delta"));
    std::cout << "\033[32m[SnapshotLoader] Successfully loaded snapshot file field data\033[0m\n";
}
 
template <typename T>
void SnapshotLoader<T>::overwriteIniFiles(
    SimulationClassBase<T>* sim,
    std::vector<std::shared_ptr<GenericManagingModule<T>>>& all_modules,
    std::vector<std::shared_ptr<GenericSubmodule<T>>>& all_submodules)
{
    if (m_no_snapshot || m_keep_module_inis)
    {
        return;
    }
    std::vector<std::string> all_module_names;
    all_module_names = m_snapshot_ini_data->getModuleNames();
 
    bool module_placed{false};
    for (const auto& module_name : all_module_names)
    {
        if (module_name == "SimulationConfig")
        {
            module_placed = true;
        }
        for (const auto& loaded_module : all_modules)
        {
            if (module_placed)
            {
                break;
            }
            if (module_name == loaded_module->getNameLocal())
            {
                loaded_module->overwriteLocalIniContent(
                    m_snapshot_ini_data->getModuleContents(module_name));
                module_placed = true;
            }
        }
 
        for (const auto& loaded_submodule : all_submodules)
        {
            if (module_placed)
            {
                break;
            }
            if (module_name == loaded_submodule->getNameLocal())
            {
                loaded_submodule->overwriteLocalIniContent(
                    m_snapshot_ini_data->getModuleContents(module_name));
                module_placed = true;
            }
        }
        if (module_placed)
        {
            module_placed = false;
        }
        else
        {
            std::cerr << "[SnapshotLoader] Couldn't find module: " << module_name
                      << " in all loaded modules. Please load this module to complete snapshot "
                         "loading.\n";
            throw std::runtime_error(
                "Couldn't find specified module from snapshot file in all loaded modules.\n");
        }
    }
    std::cout
        << "\033[32m[SnapshotLoader] Successfully loaded snapshot file module ini files\033[0m\n";
}
 
template <typename T>
void SnapshotLoader<T>::overwriteSimConfig(SimulationClassBase<T>* sim)
{
    if (m_no_snapshot || m_keep_sim_config)
    {
        return;
    }
    for (const auto& [key, map_content] :
         m_snapshot_ini_data->getModuleContents("SimulationConfig"))
    {
        // Do not write snapshot save file into the config/overwrite it, as it would lead to a loop
        // that always overwrites the current snapshot.
        if (key != "snapshot_save_file")
        {
            sim->m_simulation_config.forceValueOverwrite(key,
                                                         std::any_cast<std::string>(map_content));
        }
    }
    std::cout << "\033[32m[SnapshotLoader] Successfully loaded snapshot file simulation "
                 "configuration data\033[0m\n";
}